public void AddAll(List <T> items) { var added = false; Snapshot(); for (var i = 0; i < items.Count; i++) { var item = items[i]; Insist.IsNotNull(item, "item cannot be null"); added = selected.AddIfNotPresent(item); } if (added) { if (programmaticChangeEvents && FireChangeEvent()) { Revert(); } else { lastSelected = items.LastOrDefault(); Changed(); } } Cleanup(); }
/// <summary> /// Sets the selection to only the specified item /// </summary> /// <param name="item">Item.</param> public Selection <T> Set(T item) { Insist.IsNotNull(item, "item cannot be null."); if (selected.Count == 1 && selected.First() == item) { return(this); } Snapshot(); selected.Clear(); selected.Add(item); if (programmaticChangeEvents && FireChangeEvent()) { Revert(); } else { lastSelected = item; Changed(); } Cleanup(); return(this); }
/// <summary> /// Jon Skeet's excellent reimplementation of LINQ Count. /// </summary> /// <typeparam name="TSource">The source type.</typeparam> /// <param name="source">The source IEnumerable.</param> /// <returns>The number of items in the source.</returns> public static int Count <TSource>(this IEnumerable <TSource> source) { Insist.IsNotNull(source, "source cannot be null"); // Optimization for ICollection<T> var genericCollection = source as ICollection <TSource>; if (genericCollection != null) { return(genericCollection.Count); } // Optimization for ICollection var nonGenericCollection = source as ICollection; if (nonGenericCollection != null) { return(nonGenericCollection.Count); } // Do it the slow way - and make sure we overflow appropriately checked { int count = 0; using (var iterator = source.GetEnumerator()) { while (iterator.MoveNext()) { count++; } } return(count); } }
public override TaskStatus Update(T context) { Insist.IsNotNull(Child, "child must not be null"); // early out if we are done. we check here and after running just in case the count is 0 if (!RepeatForever && _iterationCount == Count) { return(TaskStatus.Success); } var status = Child.Tick(context); _iterationCount++; if (EndOnFailure && status == TaskStatus.Failure) { return(TaskStatus.Success); } if (!RepeatForever && _iterationCount == Count) { return(TaskStatus.Success); } return(TaskStatus.Running); }
/// <summary> /// Removes the specified data from the counting bloom filter. /// </summary> /// <param name="data">The data to remove from this counting bloom filter.</param> /// <exception cref="System.ArgumentNullException"> /// Thrown if data is null. /// </exception> /// <exception cref="System.ArgumentException"> /// Thrownf if data is empty. /// </exception> public void Remove(byte[] data) { #region Input validation Insist.IsNotNull(data, "data"); Insist.IsNotEmpty(data, "data"); #endregion int[] computedIndeces = GetIndeces(data); _lock.EnterWriteLock(); try { foreach (int index in computedIndeces) { if (_bucketStorage[index] > 0) { _bucketStorage[index]--; } } } finally { _lock.ExitWriteLock(); } }
public ListBox <T> SetStyle(ListBoxStyle style) { Insist.IsNotNull(style, "style cannot be null"); _style = style; InvalidateHierarchy(); return(this); }
/// <summary> /// Checks to see if the supplied data has been added to this filter. /// </summary> /// <param name="data"> /// The data to check for presence in the filter. /// </param> /// <returns> /// True if the item *might* have been added to the filter. False if it /// definitely has not. /// </returns> /// <exception cref="System.ArgumentNullException"> /// Thrown if data is null. /// </exception> /// <exception cref="System.ArgumentException"> /// Thrownf if data is empty. /// </exception> public bool IsPresent(byte[] data) { #region Input validation Insist.IsNotNull(data, "data"); Insist.IsNotEmpty(data, "data"); #endregion int[] computedIndeces = GetIndeces(data); _lock.EnterReadLock(); try { foreach (int index in computedIndeces) { if (IsBucketInUse(index) == false) { return(false); } } } finally { _lock.ExitReadLock(); } return(true); }
private static List <Move> GenerateMovesWithoutCheck(Cell cell) { Insist.IsNotNull(cell); Insist.IsNotNull(cell.piece); var moves = new List <Move>(); // Rename // For each type of movement defined for the piece in this cell foreach (MoveDefinition moveDef in cell.piece.type.moveSet.moves) { if (GameBoard.Instance.Layout == BoardLayout.DefaultLayout || GameBoard.Instance.Layout == BoardLayout.FlippedDefaultLayout) { moves.AddRange(GetCastlingMoves(cell)); if (cell.piece.type != PieceType.Pawn) { moves.AddRange(GetEnPassentMoves(cell)); } } if (moveDef is LeaperMoveDefinition) { moves.AddRange(AddLeaperMoves(moveDef, cell, (moveDef as LeaperMoveDefinition).leapDistance, moves)); continue; } moves.AddRange(AddBasicMoves(cell, moveDef)); } return(moves); }
public void RemoveAll(List <T> items) { var removed = false; Snapshot(); for (var i = 0; i < items.Count; i++) { var item = items[i]; Insist.IsNotNull(item, "item cannot be null"); removed = selected.Remove(item); } if (removed) { if (programmaticChangeEvents && FireChangeEvent()) { Revert(); } else { lastSelected = null; Changed(); } } Cleanup(); }
public Selection <T> SetAll(List <T> items) { var added = false; Snapshot(); lastSelected = null; selected.Clear(); for (var i = 0; i < items.Count; i++) { var item = items[i]; Insist.IsNotNull(item, "item cannot be null"); added = selected.AddIfNotPresent(item); } if (added) { if (programmaticChangeEvents && FireChangeEvent()) { Revert(); } else if (items.Count > 0) { lastSelected = items.Last(); Changed(); } } Cleanup(); return(this); }
public static void Sort <TKey, TValue>(this IDictionary <TKey, TValue> collection, Comparison <KeyValuePair <TKey, TValue> > comparison) { _logger.DebugMethodCalled(collection, comparison); #region Input Validation Insist.IsNotNull(collection, "collection"); #endregion List <KeyValuePair <TKey, TValue> > sortedItems = new List <KeyValuePair <TKey, TValue> >(); foreach (KeyValuePair <TKey, TValue> pair in collection) { sortedItems.Add(pair); } sortedItems.Sort(comparison); collection.Clear(); foreach (KeyValuePair <TKey, TValue> pair in sortedItems) { collection.Add(pair.Key, pair.Value); } }
public static IList <T> FromIndexes <T>(this IList <T> list, IndexOutOfRangeBehaviour outOfRange, params int[] indexes) { #region Input validation Insist.IsNotNull(list, "list"); Insist.IsNotNull(indexes, "indexes"); Insist.IsDefined(outOfRange, "outOfRange"); #endregion List <T> items = new List <T>(); if (list.Count == 0) { return(items); } foreach (int index in indexes) { if (index >= list.Count) //Out of bounds { if (outOfRange == IndexOutOfRangeBehaviour.Ignore) { continue; } } items.Add(list[index]); } return(items); }
/// <summary> /// Serilialize the supplied object to the supplied stream. /// </summary> /// <param name="obj"> /// The object to serialize /// </param> /// <param name="stream"> /// The stream to write the serialized object to. This stream will remain unaffected if the /// object is null. The stream must be open and writable before calling this method. /// </param> public void Serialize(object obj, Stream stream) { _logger.DebugMethodCalled(obj, stream); #region Input Validation if (obj == null) //Just do nothing for null objects, we don't want to throw //an exception because it will force more null checking in calling code. { return; } Insist.IsNotNull(stream, "stream"); if (!stream.CanWrite) { throw new ArgumentException("Cannot write to stream", "stream"); } #endregion //Delegate the actual serialization to a child class. OnSerialize(obj, stream); }
public bool Contains(T node) { Insist.IsNotNull(node, "node cannot be null"); Insist.IsFalse(node.QueueIndex < 0 || node.QueueIndex >= _nodes.Length, "node.QueueIndex has been corrupted. Did you change it manually? Or add this node to another queue?"); return(_nodes[node.QueueIndex] == node); }
/// <summary> /// Checks to ensure that the dataset is not null, has the specified number of tables /// and whether or not each table MUST have rows in it. /// </summary> /// <param name="requiredNumberOfTables"> /// The number of tables that dataset must contain /// </param> /// <param name="tableMustHaveRowsFlags"> /// A list of boolean flags denoting whether each table in the set MUST have some rows in it. /// e.g. /// /// DataSet ds = GetSomeDataSet(); /// ds.IsPopulated(3, true, false, true); /// /// means that the dataset MUST have 3 tables. The first and third tables MUST have rows in them, /// the second table may or may not have rows in it. /// </param> /// <returns> /// True if the the tables required to be populated actually are, otherwise false. /// </returns> public static bool IsPopulated(this DataSet ds, int requiredNumberOfTables, params bool[] tableMustHaveRowsFlags) { _logger.DebugMethodCalled(ds, requiredNumberOfTables, tableMustHaveRowsFlags); #region Input validation Insist.IsAtLeast(requiredNumberOfTables, 1, "requiredNumberOfTables"); Insist.IsNotNull(tableMustHaveRowsFlags, "tableMustHaveRowsFlags"); Insist.Equality(tableMustHaveRowsFlags.Length, requiredNumberOfTables, "tableMustHaveRowsFlags", "The number of tableMustHaveRowsFlags must match the number of tables"); #endregion if (ds == null || ds.Tables == null || ds.Tables.Count != requiredNumberOfTables) { return(false); } else { for (int i = 0; i < requiredNumberOfTables; i++) { if (tableMustHaveRowsFlags[i] == true && ( ds.Tables[i].Rows == null || ds.Tables[i].Rows.Count == 0 )) { return(false); } } return(true); } }
/// <summary> /// Selects or deselects the specified item based on how the selection is configured, whether ctrl is currently pressed, etc. /// This is typically invoked by user interaction. /// </summary> /// <param name="item">Item.</param> public virtual void Choose(T item) { Insist.IsNotNull(item, "item cannot be null"); if (_isDisabled) { return; } Snapshot(); try { if ((toggle || (!required && selected.Count == 1) || InputUtils.IsControlDown()) && selected.Contains(item)) { if (required && selected.Count == 1) { return; } selected.Remove(item); lastSelected = null; } else { bool modified = false; if (!multiple || (!toggle && !InputUtils.IsControlDown())) { if (selected.Count == 1 && selected.Contains(item)) { return; } modified = selected.Count > 0; selected.Clear(); } if (!selected.AddIfNotPresent(item) && !modified) { return; } lastSelected = item; } if (FireChangeEvent()) { Revert(); } else { Changed(); } } finally { Cleanup(); } }
public ScrollPane(Element widget, ScrollPaneStyle style) { Insist.IsNotNull(style, "style cannot be null"); transform = true; _style = style; SetWidget(widget); SetSize(150, 150); }
public ScrollPane SetStyle(ScrollPaneStyle style) { Insist.IsNotNull(style, "style cannot be null"); _style = style; InvalidateHierarchy(); return(this); }
public void UpdatePriority(T node, int priority) { Insist.IsNotNull(node, "node cannot be null"); Insist.IsFalse(Contains(node), "Cannot call UpdatePriority() on a node which is not enqueued: " + node); node.Priority = priority; OnNodeUpdated(node); }
public void IsNotNull_2_Thrown_Exception_Has_Correct_Argument_Name() { try { Insist.IsNotNull(null, ARGUMENT_NAME); } catch (ArgumentNullException e) { Assert.AreEqual(ARGUMENT_NAME, e.ParamName); } }
/// <summary> /// Generates a random string that is as long as length /// </summary> /// <param name="random"> /// The random number generator to use /// </param> /// <param name="length"> /// The length of the string to be generated. Returns an empty string if length /// is zero. /// </param> /// <param name="allowNumbers"> /// Whether or not to allow numbers in the generated string /// </param> /// <param name="allowSymbols"> /// Whether or not to allow symbols in the string /// </param> /// <returns> /// A random string of the specified length /// </returns> /// <exception cref="System.ArgumentNullException"> /// Thrown when random is null /// </exception> /// <exception cref="System.ArgumentException"> /// Throw when length is less than 0. /// </exception> public static string NextString(this Random random, int length, bool allowNumbers, bool allowSymbols) { #region Input Validation Insist.IsNotNull(random, "random"); Insist.IsAtLeast(length, 0, "length"); #endregion if (length == 0) { return(string.Empty); } StringBuilder builder = new StringBuilder(); while (builder.Length < length) { //+1 because MaxValue is exclusive but minValue is inclusive int i = random.Next(STARTING_ASCII_CODE, ENDING_ASCII_CODE + 1); bool isNumber = false; bool isSymbol = false; bool canAdd = true; if ((i >= UPPERCASE_ALPHABET_STARTING_CODE && i <= UPPERCASE_ALPHABET_ENDING_CODE) || (i >= LOWERCASE_ALPHABET_STARTING_CODE && i <= LOWERCASE_ALPHABET_ENDING_CODE)) { canAdd = true; } else if (i >= NUMBER_STARTING_CODE && i <= NUMBER_ENDING_CODE) { isNumber = true; } else { isSymbol = true; } if (isNumber == true && allowNumbers == false) { canAdd = false; } if (isSymbol == true && allowSymbols == false) { canAdd = false; } if (canAdd) { builder.Append((char)i); } } return(builder.ToString()); }
/// <summary> /// An extension method to raise an event that includes the null check. /// </summary> /// <typeparam name="T"> /// The eventArgs type /// </typeparam> /// <param name="theEvent"> /// The event handler to invoke /// </param> /// <param name="sender"> /// The sender object /// </param> /// <param name="args"> /// The event arguments /// </param> /// <exception cref="System.ArgumentNullException"> /// Thrown if sender is null /// </exception> public static void Raise <T>(this EventHandler <T> theEvent, object sender, T args) where T : EventArgs { Insist.IsNotNull(sender, "sender"); if (theEvent != null) { theEvent(sender, args); } }
/// <summary> /// Create new scope instace around the underlying value /// </summary> protected Scope(T value) { #region Input validation Insist.IsNotNull(value, "value"); #endregion _value = value; }
/// <summary> /// Collates all Right values from a set of eithers /// </summary> /// <param name="eithers"> /// The set of eithers from which to obtain the left values /// </param> /// <returns> /// All the left values from the supplied set of eithers /// </returns> public static IEnumerable <TRight> Rights <TLeft, TRight>(IEnumerable <Either <TLeft, TRight> > eithers) { #region Input validation Insist.IsNotNull(eithers, "eithers"); #endregion return(eithers.Where(e => e.HasRight).Select(e => e.RightValue)); }
/// <summary> /// Creates a new instance /// </summary> /// <exception cref="System.ArgumentNullException"> /// Thrown if comparison is null. /// </exception> public GenericEqualityComparer(Func <T, T, bool> comparison) { #region Input Validation Insist.IsNotNull(comparison, "comparison"); #endregion _comparison = comparison; }
public void IsNotNull_2_Thrown_Exception_Has_Correct_Message() { try { Insist.IsNotNull(null, ARGUMENT_NAME, MESSAGE); } catch (ArgumentNullException e) { Assert.IsTrue(e.Message.Contains(MESSAGE)); } }
/// <summary> /// Create a disposer to provide onEnter and onExit functionality. /// </summary> /// <param name="onEnter"></param> /// <param name="onExit"></param> /// <returns></returns> protected Disposer <T> Create(Action <T> onEnter, Action <T> onExit) { #region Input validation Insist.IsNotNull(onEnter, "onEnter"); Insist.IsNotNull(onExit, "onExit"); #endregion return(Disposer <T> .Create(_value, onEnter, onExit)); }
/// <summary> /// Hashes a string using the supplied encoding and the supplied hashing algorithm /// </summary> /// <param name="str"> /// The string to compute the hash for /// </param> /// <param name="hashAlgorithm"> /// The hashing algorithm to use to perform the hash. /// </param> /// <param name="encoding"> /// The encoding used to encode the string into a byte[] /// </param> /// <returns> /// A string representing the hash of the original input string. /// </returns> /// <exception cref="ArgumentException"> /// Thrown if str is null or empty. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if hashAlgorithm is null or encoding is null. /// </exception> public static string Hash(this string str, HashAlgorithm hashAlgorithm, Encoding encoding) { _logger.DebugMethodCalled(str, hashAlgorithm, encoding); Insist.IsNotNullOrEmpty(str, "str"); Insist.IsNotNull(hashAlgorithm, "hashAlgorithm"); Insist.IsNotNull(encoding, "encoding"); byte[] strBytes = encoding.GetBytes(str); byte[] hashed = hashAlgorithm.ComputeHash(strBytes, 0, strBytes.Length); return(BitConverter.ToString(hashed).Replace("-", "")); }
/// <summary> /// Sets the minWidth, prefWidth, maxWidth, minHeight, prefHeight, and maxHeight to the specified value. /// </summary> /// <param name="size">Size.</param> public Cell Size(Value size) { Insist.IsNotNull(size, "size cannot be null."); minWidth = size; minHeight = size; prefWidth = size; prefHeight = size; maxWidth = size; maxHeight = size; return(this); }
/// <summary> /// Returns a flag indicating whether the given item in a collection is of integral type. /// </summary> /// <param name="collection">The collection to look in.</param> /// <param name="key">The key to look at.</param> /// <returns>True if the value is integral; false otherwise.</returns> public static bool IsInteger <TKey>(this IDictionary <TKey, String> collection, TKey key) { _logger.DebugMethodCalled(collection, key); #region Input Validation Insist.IsNotNull(collection, "collection"); #endregion return(RegexHelper.IsInteger(collection[key])); }