/// <summary> /// Returns all the items in the collection which match the flag specified. /// </summary> /// <param name="include">boolean to indicate if names are to be ignored or not, false for ignore.</param> /// <param name="flag">Flag that is present on the item such as disabled, tracked, throws, etc.</param> /// <returns>Returns a ModelItems collection</returns> /// <returns></returns> public virtual ModelItems <T> FindFlag(int flag, bool include) { //Construct the typed collection (ie: (Models)Find). //The simplest, without dealing with constructors, is to clone and clear ModelItems <T> items = (ModelItems <T>) this.Clone(); items.Clear(); //Note: there could be more than one (even by the same name) /// Implementation Note: All internal enumeration should be performed on this instead of _list /// to ensure that any overriden GetEnumerator() can dictate how enumeration is performed /// over the list items. foreach (T item in this) { if (include) { if (item.IsFlag(flag)) { items.Add(item); } } else { if (item.IsFlagExcept(flag)) { items.Add(item); } } } return(items); }
/// <summary> /// Returns a collection of items found except those specified. /// </summary> /// <param name="names">Names to ignore while returning.</param> /// <returns>ModelItems collection</returns> public virtual ModelItems <T> FindExcept(params string[] names) { //Construct the typed collection (ie: (Models)Find). //The simplest, without dealing with constructors, is to clone and clear ModelItems <T> items = (ModelItems <T>) this.Clone(); items.Clear(); //Find all items that don't match ANY of the names //Note: This doesn't need to perserve the order, so matching this a seperate function (simplier) /// Implementation Note: All internal enumeration should be performed on this instead of _list /// to ensure that any overriden GetEnumerator() can dictate how enumeration is performed /// over the list items. foreach (T item in this) { bool matched = false; foreach (string name in names) { //Delegate if (String.Compare(item.Name, name, true /*ignore case*/) == 0) { matched = true; break; } } if (!matched) { items.Add(item); } } return(items); }
/// <summary> /// Returns a collection of items found for the given names. /// </summary> /// <param name="names">Names of items. (usually type.ToString)</param> /// <returns>ModelItems collection</returns> public virtual ModelItems <T> Find(params string[] names) { //Construct the typed collection (ie: (Models)Find). //The simplest, without dealing with constructors, is to clone and clear ModelItems <T> items = (ModelItems <T>) this.Clone(); items.Clear(); //Note: To perserve the order, we need to loop over the names in the outer loop //instead of the inner, which makes the exclusion (ie: include=false) more difficult foreach (string name in names) { /// Implementation Note: All internal enumeration should be performed on this instead of _list /// to ensure that any overriden GetEnumerator() can dictate how enumeration is performed /// over the list items. foreach (T item in this) { //Compare bool matched = String.Compare(item.Name, name, true /*ignore case*/) == 0; if (matched) { items.Add(item); } } } return(items); }
/// <summary> /// Overridden Clone method to copy this item. /// </summary> /// <returns></returns> public virtual object Clone() { ModelItems <T> clone = (ModelItems <T>) this.MemberwiseClone(); clone._list = new List <T>(); clone.Add(this); return(clone); }
/// <summary> /// Removes a collection of model items from this collection. /// </summary> /// <param name="items"></param> /// <returns></returns> public virtual ModelItems <T> Remove(ModelItems <T> items) { foreach (T item in items) { this.Remove(item); } return(items); }
/// <summary> /// Adds another ModelItems collection to this collection. /// </summary> /// <param name="items"></param> /// <returns></returns> public virtual ModelItems <T> Add(ModelItems <T> items) { foreach (T item in items) { this.Add(item); } return(items); }
/// <summary> /// Named indexer. /// </summary> public virtual T this[string name] { //Find first, fail if not found, although make it easier to debug get { ModelItems <T> found = this.Find(name); if (found == null || found.Count <= 0) { throw new IndexOutOfRangeException(this.Name + "['" + name + "'] is not found"); } return(found.First); } }
/// <summary> /// Returns a collection of ModelItems that do not define the given label /// </summary> /// <param name="label">Label to find by</param> /// <returns>Returns a ModelItem collection</returns> public virtual ModelItems <T> FindByNoLabel(object label) { //Construct itself without bothering about constructors. ModelItems <T> items = (ModelItems <T>) this.Clone(); items.Clear(); /// Implementation Note: All internal enumeration should be performed on this instead of _list /// to ensure that any overriden GetEnumerator() can dictate how enumeration is performed /// over the list items. foreach (T item in this) { if (item.CompareLabel(label) != 0) { items.Add(item); } } return(items); }