public StreamTypeNamer(string prefix) { Precondition.For(prefix, nameof(prefix)).NotNullOrWhiteSpace(); this.prefix = prefix; }
public T CreateComponentFromComponentType <T>(Type componentType) where T : IComponent { Precondition.ArgumentNotNull(componentType, nameof(componentType)); Precondition.ArgumentCompatibleType(componentType, typeof(IComponent), nameof(componentType)); return((T)ComponentFactoryWrapper.From(_registeredComponentFactories[componentType]).Create()); }
public ThreadedWork(Action finishedWorkCallback) { Precondition.IsNotNull(finishedWorkCallback); this.FinishedWorkCallback = finishedWorkCallback; }
/// <summary> /// 确认按钮点击 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void sureButton_Click(object sender, EventArgs e) { string error = null; if (!this.checkDatas(ref error)) { MessageBox.Show(error, "错误", MessageBoxButtons.OK); return; } if (this.editPrecondition != null)//编辑 { Precondition tmpP = new Precondition(); tmpP.name = this.editPrecondition.name; tmpP.type = this.editPrecondition.type; this.editPrecondition.name = this.nameTextBox.Text.Trim(new char[] { '\n', ' ' }); this.editPrecondition.type = this.typeTextBox.Text.Trim(new char[] { '\n', ' ' }); this.editPrecondition.childCount = (int)this.numericUpDown1.Value; this.editPrecondition.isBase = this.isBasePCheckBox.Checked; if (this.editPrecondition.childCount > 0 && !this.isBasePCheckBox.Checked) { this.editPrecondition.child = new List <Precondition>(); if (this.editPrecondition.childCount >= 1) { Precondition child1 = this.childDatas[this.child1CheckedListBox.SelectedIndex]; this.editPrecondition.child.Add(child1); } if (this.editPrecondition.childCount >= 2) { Precondition child2 = this.childDatas[this.child2CheckedListBox.SelectedIndex]; this.editPrecondition.child.Add(child2); } } List <Precondition> parms = new List <Precondition>(); parms.Add(tmpP); parms.Add(this.editPrecondition); NotificationCenter.DefaultCenter().postNotification("PreconditionUpdate", parms); } else { Precondition newP = new Precondition(); newP.name = this.nameTextBox.Text.Trim(new char[] { '\n', ' ' }); newP.type = this.typeTextBox.Text.Trim(new char[] { '\n', ' ' }); newP.childCount = (int)this.numericUpDown1.Value; newP.isBase = this.isBasePCheckBox.Checked; if (newP.childCount > 0 && !this.isBasePCheckBox.Checked) { newP.child = new List <Precondition>(); if (newP.childCount >= 1) { Precondition child1 = this.childDatas[this.child1CheckedListBox.SelectedIndex]; newP.child.Add(child1); } if (newP.childCount >= 2) { Precondition child2 = this.childDatas[this.child2CheckedListBox.SelectedIndex]; newP.child.Add(child2); } } this.childPreconditions.Add(newP); } if (this.m_delegate != null) { this.m_delegate.RefreshPrecondition(); } this.Close(); }
/// <summary> /// Visits the specified precondition. /// </summary> /// <param name="precondition">The precondition.</param> public virtual IPrecondition Visit(Precondition precondition) { precondition.Condition = this.Visit(precondition.Condition); if (precondition.Description != null) precondition.Description = this.Visit(precondition.Description); if (precondition.ExceptionToThrow != null) precondition.ExceptionToThrow = this.Visit(precondition.ExceptionToThrow); return precondition; }
private void CheckRange(int length) { Precondition.InRange(Position + length, 0, Buffer.Length, $"Not enough space in packet: {ToString()}\n"); }
public static bool TryFormat(this Guid value, Span <byte> buffer, out int bytesWritten, TextFormat format = default(TextFormat), EncodingData encoding = default(EncodingData)) { if (format.IsDefault) { format.Symbol = 'G'; } Precondition.Require(format.Symbol == 'G' || format.Symbol == 'D' || format.Symbol == 'N' || format.Symbol == 'B' || format.Symbol == 'P'); bool dash = true; char tail = '\0'; bytesWritten = 0; switch (format.Symbol) { case 'D': case 'G': break; case 'N': dash = false; break; case 'B': if (!TryWriteChar('{', buffer, ref bytesWritten, encoding)) { return(false); } tail = '}'; break; case 'P': if (!TryWriteChar('(', buffer, ref bytesWritten, encoding)) { return(false); } tail = ')'; break; default: Precondition.Require(false); // how did we get here? break; } var byteFormat = new TextFormat('x', 2); unsafe { byte *bytes = (byte *)&value; if (!TryWriteByte(bytes[3], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[2], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[1], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[0], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, ref bytesWritten, encoding)) { return(false); } } if (!TryWriteByte(bytes[5], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[4], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, ref bytesWritten, encoding)) { return(false); } } if (!TryWriteByte(bytes[7], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[6], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, ref bytesWritten, encoding)) { return(false); } } if (!TryWriteByte(bytes[8], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[9], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, ref bytesWritten, encoding)) { return(false); } } if (!TryWriteByte(bytes[10], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[11], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[12], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[13], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[14], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } if (!TryWriteByte(bytes[15], buffer, ref bytesWritten, byteFormat, encoding)) { return(false); } } if (tail != '\0') { if (!TryWriteChar(tail, buffer, ref bytesWritten, encoding)) { return(false); } } return(true); }
/// <summary> /// Visits the specified precondition. /// </summary> /// <param name="precondition">The precondition.</param> protected virtual IPrecondition DeepCopy(Precondition precondition) { precondition.Condition = this.Substitute(precondition.Condition); if (precondition.Description != null) precondition.Description = this.Substitute(precondition.Description); if (precondition.ExceptionToThrow != null) precondition.ExceptionToThrow = this.Substitute(precondition.ExceptionToThrow); return precondition; }
public static string Password(this HtmlControlHelper helper, string name, object value, IDictionary <string, object> attributes) { Precondition.Defined(name, () => Error.ArgumentNull("name")); return(InputBuilder(helper, "password", name, value, attributes)); }
private static string SelectBuilder(HtmlControlHelper helper, string name, MultiSelectList dataSource, bool isMultiple, IDictionary <string, object> attributes) { Precondition.Defined(name, () => Error.ArgumentNull("name")); if (attributes == null) { attributes = new ValueDictionary(); } if (isMultiple) { attributes["multiple"] = "multiple"; } else { attributes.Remove("multiple"); } HtmlElementBuilder outer = new HtmlElementBuilder("select"); outer.Attributes.Merge(attributes, true); outer.Attributes.Merge("name", name, true); if (dataSource != null) { StringBuilder builder = new StringBuilder(); IEnumerable <ListItem> listItems = dataSource.GetListItems(); string[] selectedValues = null; if (helper.DataSource.Keys.Any(k => k.Equals(name, StringComparison.OrdinalIgnoreCase))) { selectedValues = helper.DataSource.GetValue <string>(name, String.Empty) .Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); } builder.AppendLine(); foreach (ListItem item in listItems) { if (selectedValues != null) { item.Selected = selectedValues.Any(s => String.Equals(item.Value, s, StringComparison.OrdinalIgnoreCase)); } HtmlElementBuilder inner = new HtmlElementBuilder("option"); inner.InnerText = item.Text; if (item.Value != null) { inner.Attributes.Merge("value", item.Value, true); } if (item.Selected) { inner.Attributes.Merge("selected", "selected"); } builder.AppendLine(inner.ToString()); } outer.InnerHtml = builder.ToString(); } return(outer.ToString()); }
public PreconditionNot(Precondition precondition) { this.precondition = precondition; }
internal void AddPrecondition(Precondition precondition) { if (this.Preconditions == null) { this.Preconditions = new List<Precondition>(); this.HasContract = true; } this.Preconditions.Add(precondition); }
/// <summary> /// Rewrites the children of the given pre condition. /// </summary> public virtual void RewriteChildren(Precondition precondition) { this.RewriteChildren((ContractElement)precondition); if (precondition.ExceptionToThrow != null) precondition.ExceptionToThrow = this.Rewrite(precondition.ExceptionToThrow); }
private static bool TryFormatHexadecimalInvariantCultureUtf8(ulong value, Span <byte> buffer, out int bytesWritten, StandardFormat format) { Precondition.Require(format.Symbol == 'X' || format.Symbol == 'x'); byte firstDigitOffset = (byte)'0'; byte firstHexCharOffset = format.Symbol == 'X' ? (byte)'A' : (byte)'a'; firstHexCharOffset -= 10; // Count amount of hex digits var hexDigitsCount = 1; ulong valueToCount = value; if (valueToCount > 0xFFFFFFFF) { hexDigitsCount += 8; valueToCount >>= 0x20; } if (valueToCount > 0xFFFF) { hexDigitsCount += 4; valueToCount >>= 0x10; } if (valueToCount > 0xFF) { hexDigitsCount += 2; valueToCount >>= 0x8; } if (valueToCount > 0xF) { hexDigitsCount++; } var bytesCount = hexDigitsCount; // Count leading zeros var leadingZerosCount = format.HasPrecision ? format.Precision - hexDigitsCount : 0; bytesCount += leadingZerosCount > 0 ? leadingZerosCount : 0; if (bytesCount > buffer.Length) { bytesWritten = 0; return(false); } var index = bytesCount; while (hexDigitsCount-- > 0) { byte digit = (byte)(value & 0xF); value >>= 0x4; digit += digit < 10 ? firstDigitOffset : firstHexCharOffset; buffer[--index] = digit; } // Write leading zeros if any while (leadingZerosCount-- > 0) { buffer[--index] = firstDigitOffset; } bytesWritten = bytesCount; return(true); }
private static HtmlElementRule Validate(HtmlElementRule rule) { Precondition.Require(rule, () => Error.ArgumentNull("rule")); return(rule); }
void IHttpHandler.ProcessRequest(HttpContext context) { Precondition.Require(context, () => Error.ArgumentNull("context")); ProcessRequest(new HttpContextWrapper(context)); }
public RequireUsersAttribute(params string[] users) { Precondition.Require(users, () => Error.ArgumentNull("users")); _users = users; }
/// <summary> /// A copy constructor that allocates an instance that is the same as the given template, except for its containing block. /// </summary> /// <param name="containingBlock">The containing block of the copied precondition. This should be different from the containing block of the template precondition.</param> /// <param name="template">The statement to copy.</param> private Precondition(BlockStatement containingBlock, Precondition template) : base(containingBlock, template) { if (template.ExceptionToThrow != null) this.exceptionToThrow = template.ExceptionToThrow.MakeCopyFor(containingBlock); }
public MvcHandler(RequestContext context) { Precondition.Require(context, () => Error.ArgumentNull("context")); _context = context; }
private static IDbDataProvider CreateProvider(IDbDataProviderFactory factory) { Precondition.Require(factory, () => Error.ArgumentNull("factory")); return(factory.CreateProvider()); }
//------------------------------------------------------------- public bool Evaluate(/*in*/ BTWorkingData wData) { return((Precondition == null || Precondition.IsTrue(wData)) && OnEvaluate(wData)); }
private static IValueSet EnsureValues(IValueSet values) { Precondition.Require(values, () => Error.ArgumentNull("values")); return(values); }
public MvcForm(HttpResponseBase response) { Precondition.Require(response, () => Error.ArgumentNull("response")); _response = response; }
/// <summary> /// Adds a top-level rule for the attribute. In most cases, the rule is ignored. /// </summary> /// <param name="rule">A new sub-rule to add.</param> protected virtual HtmlAttributeRule AddAttributeRule(HtmlAttributeRule rule) { Precondition.Require(rule, () => Error.ArgumentNull("rule")); return(Document.AddAttributeRule(rule)); }
public static bool TryFormat(this Guid value, Span <byte> buffer, Format.Parsed format, FormattingData formattingData, out int bytesWritten) { Precondition.Require(format.Symbol == Format.Symbol.G || format.Symbol == Format.Symbol.D || format.Symbol == Format.Symbol.N || format.Symbol == Format.Symbol.B || format.Symbol == Format.Symbol.P); bool dash = true; char tail = '\0'; bytesWritten = 0; switch (format.Symbol) { case Format.Symbol.D: case Format.Symbol.G: break; case Format.Symbol.N: dash = false; break; case Format.Symbol.B: if (!TryWriteChar('{', buffer, formattingData, ref bytesWritten)) { return(false); } tail = '}'; break; case Format.Symbol.P: if (!TryWriteChar('(', buffer, formattingData, ref bytesWritten)) { return(false); } tail = ')'; break; default: Precondition.Require(false); // how did we get here? break; } var bytes = value.ToByteArray(); // TODO: it would be nice to eliminate this allocation var byteFormat = new Format.Parsed() { Precision = 2, Symbol = Format.Symbol.XLowercase }; if (!TryWriteByte(bytes[3], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[2], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[1], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[0], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, formattingData, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[5], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[4], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, formattingData, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[7], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[6], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, formattingData, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[8], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[9], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, formattingData, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[10], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[11], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[12], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[13], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[14], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[15], buffer, byteFormat, formattingData, ref bytesWritten)) { return(false); } if (tail != '\0') { if (!TryWriteChar(tail, buffer, formattingData, ref bytesWritten)) { return(false); } } return(true); }
public TemplateHelper(HtmlHelper helper) { Precondition.Require(helper, () => Error.ArgumentNull("helper")); _helper = helper; }
protected virtual ValidationRule <T> GetSut <T>(T value, string name) { return(Precondition.For(value, name)); }
public void Add(string name, IValueProviderFactory factory) { Precondition.Require(factory, () => Error.ArgumentNull("factory")); _collection[name] = factory; }
protected override ValidationRule <bool> GetSut() { return(Precondition.For(ExpectedValue, "BB")); }
public static bool TryFormat(this float value, Span <byte> buffer, Format.Parsed format, FormattingData formattingData, out int bytesWritten) { Precondition.Require(format.Symbol == Format.Symbol.G); return(FloatFormatter.TryFormatNumber(value, true, buffer, format, formattingData, out bytesWritten)); }
/// <summary> /// Parses an unsigned 64-bit integer from a location within a UTF-8 byte array buffer. /// </summary> /// <param name="utf8Text">The UTF-8 buffer, passed as a byte array.</param> /// <param name="index">The index location of the value to be parsed within the buffer.</param> /// <param name="value">The parsed value.</param> /// <param name="bytesConsumed">The length (in bytes) of the unparsed value within the UTF-8 buffer.</param> /// <returns>True if parsing is successful; false otherwise.</returns> public static bool TryParse(byte[] utf8Text, int index, out sbyte value, out int bytesConsumed) { Precondition.Require(utf8Text.Length > 0); value = 0; bytesConsumed = 0; bool negative = false; bool signed = false; if (utf8Text[index] == '-') { negative = true; signed = true; index++; bytesConsumed++; } else if (utf8Text[index] == '+') { signed = true; index++; bytesConsumed++; } for (int byteIndex = index; byteIndex < utf8Text.Length; byteIndex++) // loop through the byte array { byte nextByte = utf8Text[byteIndex]; if (nextByte < '0' || nextByte > '9') // if the next character is not a digit { if (bytesConsumed == 1 && signed) // if the first character happened to be a '-' or a '+', we reset the byte counter so logic proceeds as normal. { bytesConsumed = 0; } if (bytesConsumed == 0) // check to see if we've processed any digits at all { value = default(int); // if we haven't, set value to 0 and return false return(false); } else { if (negative) // We check if the value is negative at the very end to save on comp time { value = (sbyte)-value; } return(true); // otherwise return true } } sbyte candidate = (sbyte)(value * 10); // left shift the value candidate += (sbyte)(nextByte - '0'); // parse the current digit to a sbyte and add it to the temporary value if (candidate >= value) // if it was a digit 0-9, this should be true { value = candidate; } else // for signed types this will occur at the min values as overflow occurs during addition, so we handle that { if (candidate == sbyte.MinValue) { bytesConsumed++; value = candidate; return(true); } if (negative) // We check if the value is negative at the very end to save on comp time { value = (sbyte)-value; } return(true); } bytesConsumed++; // increment the number of bytes consumed, then loop } if (negative) // We check if the value is negative at the very end to save on comp time { value = (sbyte)-value; } return(true); }
// TODO: this whole routine is too slow. It does div and mod twice, which are both costly (especially that some JITs cannot optimize it). // It does it twice to avoid reversing the formatted buffer, which can be tricky given it should handle arbitrary cultures. // One optimization I thought we could do is to do div/mod once and store digits in a temp buffer (but that would allocate). Modification to the idea would be to store the digits in a local struct // Another idea possibly worth tying would be to special case cultures that have constant digit size, and go back to the format + reverse buffer approach. private static bool TryFormatDecimal(ulong value, Span <byte> buffer, out int bytesWritten, StandardFormat format, SymbolTable symbolTable) { char symbol = char.ToUpperInvariant(format.Symbol); Precondition.Require(symbol == 'D' || format.Symbol == 'G' || format.Symbol == 'N'); // Reverse value on decimal basis, count digits and trailing zeros before the decimal separator ulong reversedValueExceptFirst = 0; var digitsCount = 1; var trailingZerosCount = 0; // We reverse the digits in numeric form because reversing encoded digits is hard and/or costly. // If value contains 20 digits, its reversed value will not fit into ulong size. // So reverse it till last digit (reversedValueExceptFirst will have all the digits except the first one). while (value >= 10) { var digit = value % 10UL; value = value / 10UL; if (reversedValueExceptFirst == 0 && digit == 0) { trailingZerosCount++; } else { reversedValueExceptFirst = reversedValueExceptFirst * 10UL + digit; digitsCount++; } } bytesWritten = 0; int digitBytes; // If format is D and precision is greater than digitsCount + trailingZerosCount, append leading zeros if (symbol == 'D' && format.HasPrecision) { var leadingZerosCount = format.Precision - digitsCount - trailingZerosCount; while (leadingZerosCount-- > 0) { if (!symbolTable.TryEncode(SymbolTable.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } } // Append first digit if (!symbolTable.TryEncode((SymbolTable.Symbol)value, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsCount--; if (symbol == 'N') { const int GroupSize = 3; // Count amount of digits before first group separator. It will be reset to groupSize every time digitsLeftInGroup == zero var digitsLeftInGroup = (digitsCount + trailingZerosCount) % GroupSize; if (digitsLeftInGroup == 0) { if (digitsCount + trailingZerosCount > 0) { // There is a new group immediately after the first digit if (!symbolTable.TryEncode(SymbolTable.Symbol.GroupSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } digitsLeftInGroup = GroupSize; } // Append digits while (reversedValueExceptFirst > 0) { if (digitsLeftInGroup == 0) { if (!symbolTable.TryEncode(SymbolTable.Symbol.GroupSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup = GroupSize; } var nextDigit = reversedValueExceptFirst % 10UL; reversedValueExceptFirst = reversedValueExceptFirst / 10UL; if (!symbolTable.TryEncode((SymbolTable.Symbol)nextDigit, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup--; } // Append trailing zeros if any while (trailingZerosCount-- > 0) { if (digitsLeftInGroup == 0) { if (!symbolTable.TryEncode(SymbolTable.Symbol.GroupSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup = GroupSize; } if (!symbolTable.TryEncode(SymbolTable.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup--; } } else { while (reversedValueExceptFirst > 0) { var bufferSlice = buffer.Slice(bytesWritten); var nextDigit = reversedValueExceptFirst % 10UL; reversedValueExceptFirst = reversedValueExceptFirst / 10UL; if (!symbolTable.TryEncode((SymbolTable.Symbol)nextDigit, bufferSlice, out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } // Append trailing zeros if any while (trailingZerosCount-- > 0) { if (!symbolTable.TryEncode(SymbolTable.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } } // If format is N and precision is not defined or is greater than zero, append trailing zeros after decimal point if (symbol == 'N') { int trailingZerosAfterDecimalCount = format.HasPrecision ? format.Precision : 2; if (trailingZerosAfterDecimalCount > 0) { if (!symbolTable.TryEncode(SymbolTable.Symbol.DecimalSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; while (trailingZerosAfterDecimalCount-- > 0) { if (!symbolTable.TryEncode(SymbolTable.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } } } return(true); }
protected bool IsPreconditionMet() { return(Precondition == null || Precondition.IsTrue()); }
/// <summary> /// Get the mutable copy of a precondition. /// </summary> /// <param name="precondition"></param> /// <returns></returns> public virtual Precondition GetMutableCopy(IPrecondition precondition) { object cachedValue; if (this.cache.TryGetValue(precondition, out cachedValue)) return (Precondition)cachedValue; var result = new Precondition(precondition); // Probably not necessary, no two postconditions are shared. this.cache.Add(precondition, result); this.cache.Add(result, result); return result; }
public bool TryWriteDigit(ulong digit, Span <byte> buffer, out int bytesWritten) { Precondition.Require(digit < 10); return(TryWriteDigitOrSymbol(digit, buffer, out bytesWritten)); }
public HttpContentTypeAttribute(string contentType) { Precondition.Defined(contentType, () => Error.ArgumentNull("contentType")); _contentType = contentType; }
public SingleMappedAssociationLoader(DbCommandDescriptor command) { Precondition.Require(command, () => Error.ArgumentNull("command")); _command = command; }
public PreconditionOr(Precondition precondition0, Precondition precondition1) { this.precondition0 = precondition0; this.precondition1 = precondition1; }
/// <summary> /// Visits the specified precondition. /// </summary> /// <param name="precondition">The precondition.</param> public virtual IPrecondition Visit(IPrecondition precondition) { Precondition mutablePrecondition = precondition as Precondition; if (!this.copyOnlyIfNotAlreadyMutable || mutablePrecondition == null) mutablePrecondition = new Precondition(precondition); return this.Visit(mutablePrecondition); }