1 <?xml version="1.0"?>
\r
7 <member name="T:C5.EnumerationDirection">
\r
9 Direction of enumeration order relative to original collection.
\r
12 <member name="F:C5.EnumerationDirection.Forwards">
\r
17 <member name="F:C5.EnumerationDirection.Backwards">
\r
22 <member name="T:C5.IComparer`1">
\r
24 The type of an item comparer
\r
25 <p>Implementations of this interface must asure that the method is self-consistent
\r
26 and defines a sorting order on items, or state precise conditions under which this is true.</p>
\r
27 <p>Implementations <b>must</b> assure that repeated calls of
\r
28 the method to the same (in reference or binary identity sense) arguments
\r
29 will return values with the same sign (-1, 0 or +1), or state precise conditions
\r
30 under which the user
\r
31 can be assured repeated calls will return the same sign.</p>
\r
32 <p>Implementations of this interface must always return values from the method
\r
33 and never throw exceptions.</p>
\r
34 <p>This interface is identical to System.Collections.Generic.IComparer<T></p>
\r
37 <member name="M:C5.IComparer`1.Compare(`0,`0)">
\r
39 Compare two items with respect to this item comparer
\r
41 <param name="a">First item</param>
\r
42 <param name="b">Second item</param>
\r
43 <returns>Positive if a is greater than b, 0 if they are equal, negative if a is less than b</returns>
\r
45 <member name="T:C5.IntHasher">
\r
50 <member name="T:C5.IHasher`1">
\r
52 The type of an item hasher.
\r
53 <p>Implementations of this interface <b>must</b> assure that the methods are
\r
54 consistent, i.e. that whenever two items i1 and i2 satisfies that Equals(i1,i2)
\r
55 returns true, then GetHashCode returns the same values for i1 and i2.</p>
\r
56 <p>Implementations of this interface <b>must</b> assure that repeated calls of
\r
57 the methods to the same (in reference or binary identity sense) arguments
\r
58 will return the same values, or state precise conditions under which the user
\r
59 can be assured repeated calls will return the same values.</p>
\r
60 <p>Implementations of this interface must always return values from the methods
\r
61 and never throw exceptions.</p>
\r
62 <p>This interface is similar in function to System.IKeyComparer<T></p>
\r
65 <member name="M:C5.IHasher`1.GetHashCode(`0)">
\r
67 Get the hash code with respect to this item hasher
\r
69 <param name="item">The item</param>
\r
70 <returns>The hash code</returns>
\r
72 <member name="M:C5.IHasher`1.Equals(`0,`0)">
\r
74 Check if two items are equal with respect to this item hasher
\r
76 <param name="i1">first item</param>
\r
77 <param name="i2">second item</param>
\r
78 <returns>True if equal</returns>
\r
80 <member name="M:C5.IntHasher.GetHashCode(System.Int32)">
\r
82 Get the hash code of this integer, i.e. itself
\r
84 <param name="item">The integer</param>
\r
85 <returns>The same</returns>
\r
87 <member name="M:C5.IntHasher.Equals(System.Int32,System.Int32)">
\r
89 Check if two integers are equal
\r
91 <param name="i1">first integer</param>
\r
92 <param name="i2">second integer</param>
\r
93 <returns>True if equal</returns>
\r
95 <member name="T:C5.NaturalComparer`1">
\r
97 A natural generic IComparer for an IComparable<T> item type
\r
100 <member name="M:C5.NaturalComparer`1.Compare(`0,`0)">
\r
104 <param name="a">First item</param>
\r
105 <param name="b">Second item</param>
\r
106 <returns>a <=> b</returns>
\r
108 <member name="T:C5.NaturalComparerO`1">
\r
110 A natural generic IComparer for a System.IComparable item type
\r
113 <member name="M:C5.NaturalComparerO`1.Compare(`0,`0)">
\r
117 <param name="a">First item</param>
\r
118 <param name="b">Second item</param>
\r
119 <returns>a <=> b</returns>
\r
121 <member name="T:C5.DefaultReferenceTypeHasher`1">
\r
123 The default item hasher for a reference type. A trivial wrapper for calling
\r
124 the GetHashCode and Equals methods inherited from object.
\r
126 <p>Should only be instantiated with a reference type as generic type parameter.
\r
127 This is asserted at instatiation time in Debug builds.</p>
\r
130 <member name="M:C5.DefaultReferenceTypeHasher`1.GetHashCode(`0)">
\r
132 Get the hash code with respect to this item hasher
\r
134 <param name="item">The item</param>
\r
135 <returns>The hash code</returns>
\r
137 <member name="M:C5.DefaultReferenceTypeHasher`1.Equals(`0,`0)">
\r
139 Check if two items are equal with respect to this item hasher
\r
141 <param name="i1">first item</param>
\r
142 <param name="i2">second item</param>
\r
143 <returns>True if equal</returns>
\r
145 <member name="T:C5.DefaultValueTypeHasher`1">
\r
147 The default item hasher for a value type. A trivial wrapper for calling
\r
148 the GetHashCode and Equals methods inherited from object.
\r
150 <p>Should only be instantiated with a value type as generic type parameter.
\r
151 This is asserted at instatiation time in Debug builds.</p>
\r
152 <p>We cannot add the constraint "where T : struct" to get a compile time check
\r
153 because we need to instantiate this class in C5.HasherBuilder.ByPrototype[T].Examine()
\r
154 with a T that is only known at runtime to be a value type!</p>
\r
157 <member name="M:C5.DefaultValueTypeHasher`1.GetHashCode(`0)">
\r
159 Get the hash code with respect to this item hasher
\r
161 <param name="item">The item</param>
\r
162 <returns>The hash code</returns>
\r
164 <member name="M:C5.DefaultValueTypeHasher`1.Equals(`0,`0)">
\r
166 Check if two items are equal with respect to this item hasher
\r
168 <param name="i1">first item</param>
\r
169 <param name="i2">second item</param>
\r
170 <returns>True if equal</returns>
\r
172 <member name="T:C5.EnumerableBase`1">
\r
174 A base class for implementing an IEnumerable<T>
\r
177 <member name="M:C5.EnumerableBase`1.GetEnumerator">
\r
179 Create an enumerator for this collection.
\r
181 <returns>The enumerator</returns>
\r
183 <member name="M:C5.EnumerableBase`1.countItems(System.Collections.Generic.IEnumerable{`0})">
\r
185 Count the number of items in an enumerable by enumeration
\r
187 <param name="items">The enumerable to count</param>
\r
188 <returns>The size of the enumerable</returns>
\r
190 <member name="T:C5.CollectionValueBase`1">
\r
192 Base class for classes implementing ICollectionValue[T]
\r
195 <member name="T:C5.ICollectionValue`1">
\r
197 A generic collection that may be enumerated and can answer
\r
198 efficiently how many items it contains. Like <code>IEnumerable<T></code>,
\r
199 this interface does not prescribe any operations to initialize or update the
\r
200 collection. The main usage for this interface is to be the return type of
\r
201 query operations on generic collection.
\r
204 <member name="M:C5.ICollectionValue`1.CopyTo(`0[],System.Int32)">
\r
206 Copy the items of this collection to a contiguous part of an array.
\r
208 <param name="a">The array to copy to</param>
\r
209 <param name="i">The index at which to copy the first item</param>
\r
211 <member name="M:C5.ICollectionValue`1.ToArray">
\r
213 Create an array with the items of this collection (in the same order as an
\r
214 enumerator would output them).
\r
216 <returns>The array</returns>
\r
218 <member name="M:C5.ICollectionValue`1.Apply(C5.Applier{`0})">
\r
220 Apply a delegate to all items of this collection.
\r
222 <param name="a">The delegate to apply</param>
\r
224 <member name="M:C5.ICollectionValue`1.Exists(C5.Filter{`0})">
\r
226 Check if there exists an item that satisfies a
\r
227 specific predicate in this collection.
\r
229 <param name="filter">A filter delegate
\r
230 (<see cref="T:C5.Filter!1"/>) defining the predicate</param>
\r
231 <returns>True is such an item exists</returns>
\r
233 <member name="M:C5.ICollectionValue`1.All(C5.Filter{`0})">
\r
235 Check if all items in this collection satisfies a specific predicate.
\r
237 <param name="filter">A filter delegate
\r
238 (<see cref="T:C5.Filter!1"/>) defining the predicate</param>
\r
239 <returns>True if all items satisfies the predicate</returns>
\r
241 <member name="P:C5.ICollectionValue`1.Count">
\r
245 <value>The number of items in this collection</value>
\r
247 <member name="P:C5.ICollectionValue`1.CountSpeed">
\r
249 The value is symbolic indicating the type of asymptotic complexity
\r
250 in terms of the size of this collection (worst-case or amortized as
\r
253 <value>A characterization of the speed of the
\r
254 <code>Count</code> property in this collection.</value>
\r
256 <member name="M:C5.CollectionValueBase`1.CopyTo(`0[],System.Int32)">
\r
258 Copy the items of this collection to part of an array.
\r
259 <exception cref="T:System.ArgumentOutOfRangeException"/> if i is negative.
\r
260 <exception cref="T:System.ArgumentException"/> if the array does not have room for the items.
\r
262 <param name="a">The array to copy to</param>
\r
263 <param name="i">The starting index.</param>
\r
265 <member name="M:C5.CollectionValueBase`1.ToArray">
\r
267 Create an array with the items of this collection (in the same order as an
\r
268 enumerator would output them).
\r
270 <returns>The array</returns>
\r
272 <member name="M:C5.CollectionValueBase`1.Apply(C5.Applier{`0})">
\r
274 Apply an Applier<T> to this enumerable
\r
276 <param name="a">The applier delegate</param>
\r
278 <member name="M:C5.CollectionValueBase`1.Exists(C5.Filter{`0})">
\r
280 Check if there exists an item that satisfies a
\r
281 specific predicate in this collection.
\r
283 <param name="filter">A filter delegate
\r
284 (<see cref="T:C5.Filter!1"/>) defining the predicate</param>
\r
285 <returns>True is such an item exists</returns>
\r
287 <member name="M:C5.CollectionValueBase`1.All(C5.Filter{`0})">
\r
289 Check if all items in this collection satisfies a specific predicate.
\r
291 <param name="filter">A filter delegate
\r
292 (<see cref="T:C5.Filter!1"/>) defining the predicate</param>
\r
293 <returns>True if all items satisfies the predicate</returns>
\r
295 <member name="M:C5.CollectionValueBase`1.GetEnumerator">
\r
297 Create an enumerator for this collection.
\r
299 <returns>The enumerator</returns>
\r
301 <member name="P:C5.CollectionValueBase`1.Count">
\r
303 The number of items in this collection.
\r
307 <member name="P:C5.CollectionValueBase`1.CountSpeed">
\r
309 The value is symbolic indicating the type of asymptotic complexity
\r
310 in terms of the size of this collection (worst-case or amortized as
\r
313 <value>A characterization of the speed of the
\r
314 <code>Count</code> property in this collection.</value>
\r
316 <member name="T:C5.CollectionBase`1">
\r
318 Base class (abstract) for ICollection implementations.
\r
321 <member name="F:C5.CollectionBase`1.isReadOnly">
\r
323 The underlying field of the ReadOnly property
\r
326 <member name="F:C5.CollectionBase`1.stamp">
\r
328 The current stamp value
\r
331 <member name="F:C5.CollectionBase`1.size">
\r
333 The number of items in the collection
\r
336 <member name="F:C5.CollectionBase`1.itemhasher">
\r
338 The item hasher of the collection
\r
341 <member name="M:C5.CollectionBase`1.checkRange(System.Int32,System.Int32)">
\r
343 Utility method for range checking.
\r
344 <exception cref="T:System.ArgumentOutOfRangeException"/> if the start or count is negative
\r
345 <exception cref="T:System.ArgumentException"/> if the range does not fit within collection size.
\r
347 <param name="start">start of range</param>
\r
348 <param name="count">size of range</param>
\r
350 <member name="M:C5.CollectionBase`1.ComputeHashCode(C5.ICollectionValue{`0},C5.IHasher{`0})">
\r
352 Compute the unsequenced hash code of a collection
\r
354 <param name="items">The collection to compute hash code for</param>
\r
355 <param name="itemhasher">The item hasher</param>
\r
356 <returns>The hash code</returns>
\r
358 <member name="M:C5.CollectionBase`1.StaticEquals(C5.ICollection{`0},C5.ICollection{`0},C5.IHasher{`0})">
\r
360 Examine if tit and tat are equal as unsequenced collections
\r
361 using the specified item hasher (assumed compatible with the two collections).
\r
363 <param name="tit">The first collection</param>
\r
364 <param name="tat">The second collection</param>
\r
365 <param name="itemhasher">The item hasher to use for comparison</param>
\r
366 <returns>True if equal</returns>
\r
368 <member name="M:C5.CollectionBase`1.unsequencedhashcode">
\r
370 Get the unsequenced collection hash code of this collection: from the cached
\r
371 value if present and up to date, else (re)compute.
\r
373 <returns>The hash code</returns>
\r
375 <member name="M:C5.CollectionBase`1.unsequencedequals(C5.ICollection{`0})">
\r
377 Check if the contents of that is equal to the contents of this
\r
378 in the unsequenced sense. Using the item hasher of this collection.
\r
380 <param name="that">The collection to compare to.</param>
\r
381 <returns>True if equal</returns>
\r
383 <member name="M:C5.CollectionBase`1.modifycheck(System.Int32)">
\r
385 <exception cref="T:System.InvalidOperationException"/> if this collection has been updated
\r
386 since a target time
\r
388 <param name="thestamp">The stamp identifying the target time</param>
\r
390 <member name="M:C5.CollectionBase`1.updatecheck">
\r
392 Check if it is valid to perform update operations, and if so increment stamp
\r
395 <member name="M:C5.CollectionBase`1.GetEnumerator">
\r
397 Create an enumerator for this collection.
\r
399 <returns>The enumerator</returns>
\r
401 <member name="P:C5.CollectionBase`1.IsReadOnly">
\r
405 <value>True if this collection is read only</value>
\r
407 <member name="P:C5.CollectionBase`1.Count">
\r
411 <value>The size of this collection</value>
\r
413 <member name="P:C5.CollectionBase`1.CountSpeed">
\r
415 The value is symbolic indicating the type of asymptotic complexity
\r
416 in terms of the size of this collection (worst-case or amortized as
\r
419 <value>A characterization of the speed of the
\r
420 <code>Count</code> property in this collection.</value>
\r
422 <member name="P:C5.CollectionBase`1.SyncRoot">
\r
426 <value>A distinguished object to use for locking to synchronize multithreaded access</value>
\r
428 <member name="P:C5.CollectionBase`1.IsEmpty">
\r
432 <value>True is this collection is empty</value>
\r
434 <member name="T:C5.SequencedBase`1">
\r
436 Base class (abstract) for sequenced collection implementations.
\r
439 <member name="M:C5.SequencedBase`1.ComputeHashCode(C5.ISequenced{`0},C5.IHasher{`0})">
\r
441 Compute the unsequenced hash code of a collection
\r
443 <param name="items">The collection to compute hash code for</param>
\r
444 <param name="itemhasher">The item hasher</param>
\r
445 <returns>The hash code</returns>
\r
447 <member name="M:C5.SequencedBase`1.StaticEquals(C5.ISequenced{`0},C5.ISequenced{`0},C5.IHasher{`0})">
\r
449 Examine if tit and tat are equal as sequenced collections
\r
450 using the specified item hasher (assumed compatible with the two collections).
\r
452 <param name="tit">The first collection</param>
\r
453 <param name="tat">The second collection</param>
\r
454 <param name="itemhasher">The item hasher to use for comparison</param>
\r
455 <returns>True if equal</returns>
\r
457 <member name="M:C5.SequencedBase`1.sequencedhashcode">
\r
459 Get the sequenced collection hash code of this collection: from the cached
\r
460 value if present and up to date, else (re)compute.
\r
462 <returns>The hash code</returns>
\r
464 <member name="M:C5.SequencedBase`1.sequencedequals(C5.ISequenced{`0})">
\r
466 Check if the contents of that is equal to the contents of this
\r
467 in the sequenced sense. Using the item hasher of this collection.
\r
469 <param name="that">The collection to compare to.</param>
\r
470 <returns>True if equal</returns>
\r
472 <member name="M:C5.SequencedBase`1.GetEnumerator">
\r
474 Create an enumerator for this collection.
\r
476 <returns>The enumerator</returns>
\r
478 <member name="P:C5.SequencedBase`1.Direction">
\r
480 <code>Forwards</code> if same, else <code>Backwards</code>
\r
482 <value>The enumeration direction relative to the original collection.</value>
\r
484 <member name="T:C5.ArrayBase`1">
\r
486 Base class for collection classes of dynamic array type implementations.
\r
489 <member name="F:C5.ArrayBase`1.array">
\r
491 The actual internal array container. Will be extended on demand.
\r
494 <member name="F:C5.ArrayBase`1.offset">
\r
496 The offset into the internal array container of the first item. The offset is 0 for a
\r
497 base dynamic array and may be positive for an updatable view into a base dynamic array.
\r
500 <member name="M:C5.ArrayBase`1.expand">
\r
502 Double the size of the internal array.
\r
505 <member name="M:C5.ArrayBase`1.expand(System.Int32,System.Int32)">
\r
507 Expand the internal array container.
\r
509 <param name="newcapacity">The new size of the internal array -
\r
510 will be rounded upwards to a power of 2.</param>
\r
511 <param name="newsize">The (new) size of the (base) collection.</param>
\r
513 <member name="M:C5.ArrayBase`1.insert(System.Int32,`0)">
\r
515 Insert an item at a specific index, moving items to the right
\r
516 upwards and expanding the array if necessary.
\r
518 <param name="i">The index at which to insert.</param>
\r
519 <param name="item">The item to insert.</param>
\r
521 <member name="M:C5.ArrayBase`1.#ctor(System.Int32,C5.IHasher{`0})">
\r
523 Create an empty ArrayBase object.
\r
525 <param name="capacity">The initial capacity of the internal array container.
\r
526 Will be rounded upwards to the nearest power of 2 greater than or equal to 8.</param>
\r
527 <param name="hasher">The item hasher to use, primarily for item equality</param>
\r
529 <member name="M:C5.ArrayBase`1.Clear">
\r
531 Remove all items and reset size of internal array container.
\r
534 <member name="M:C5.ArrayBase`1.ToArray">
\r
536 Create an array containing (copies) of the items of this collection in enumeration order.
\r
538 <returns>The new array</returns>
\r
540 <member name="M:C5.ArrayBase`1.Check">
\r
542 Perform an internal consistency (invariant) test on the array base.
\r
544 <returns>True if test succeeds.</returns>
\r
546 <member name="M:C5.ArrayBase`1.Backwards">
\r
548 Create a directed collection with the same contents as this one, but
\r
549 opposite enumeration sequence.
\r
551 <returns>The mirrored collection.</returns>
\r
553 <member name="M:C5.ArrayBase`1.GetEnumerator">
\r
555 Create an enumerator for this array based collection.
\r
557 <returns>The enumerator</returns>
\r
559 <member name="P:C5.ArrayBase`1.Item(System.Int32,System.Int32)">
\r
561 <exception cref="T:System.IndexOutOfRangeException"/>.
\r
563 <value>The directed collection of items in a specific index interval.</value>
\r
564 <param name="start">The low index of the interval (inclusive).</param>
\r
565 <param name="count">The size of the range.</param>
\r
567 <member name="T:C5.ArrayBase`1.Range">
\r
569 A helper class for defining results of interval queries on array based collections.
\r
572 <member name="T:C5.IDirectedCollectionValue`1">
\r
574 A sized generic collection, that can be enumerated backwards.
\r
577 <member name="T:C5.IDirectedEnumerable`1">
\r
579 A generic collection, that can be enumerated backwards.
\r
582 <member name="M:C5.IDirectedEnumerable`1.Backwards">
\r
584 Create a collection containing the same items as this collection, but
\r
585 whose enumerator will enumerate the items backwards. The new collection
\r
586 will become invalid if the original is modified. Method typicaly used as in
\r
587 <code>foreach (T x in coll.Backwards()) {...}</code>
\r
589 <returns>The backwards collection.</returns>
\r
591 <member name="P:C5.IDirectedEnumerable`1.Direction">
\r
593 <code>Forwards</code> if same, else <code>Backwards</code>
\r
595 <value>The enumeration direction relative to the original collection.</value>
\r
597 <member name="M:C5.IDirectedCollectionValue`1.Backwards">
\r
599 Create a collection containing the same items as this collection, but
\r
600 whose enumerator will enumerate the items backwards. The new collection
\r
601 will become invalid if the original is modified. Method typicaly used as in
\r
602 <code>foreach (T x in coll.Backwards()) {...}</code>
\r
604 <returns>The backwards collection.</returns>
\r
606 <member name="M:C5.ArrayBase`1.Range.GetEnumerator">
\r
608 Create an enumerator for this range of an array based collection.
\r
610 <returns>The enumerator</returns>
\r
612 <member name="M:C5.ArrayBase`1.Range.Backwards">
\r
614 Create a araay collection range with the same contents as this one, but
\r
615 opposite enumeration sequence.
\r
617 <returns>The mirrored collection.</returns>
\r
619 <member name="P:C5.ArrayBase`1.Range.Count">
\r
623 <value>The number of items in the range</value>
\r
625 <member name="P:C5.ArrayBase`1.Range.CountSpeed">
\r
627 The value is symbolic indicating the type of asymptotic complexity
\r
628 in terms of the size of this collection (worst-case or amortized as
\r
631 <value>A characterization of the speed of the
\r
632 <code>Count</code> property in this collection.</value>
\r
634 <member name="P:C5.ArrayBase`1.Range.Direction">
\r
636 <code>Forwards</code> if same, else <code>Backwards</code>
\r
638 <value>The enumeration direction relative to the original collection.</value>
\r
640 <member name="T:C5.Sorting">
\r
642 A utility class with functions for sorting arrays with respect to an IComparer<T>
\r
645 <member name="M:C5.Sorting.IntroSort``1(``0[],System.Int32,System.Int32,C5.IComparer{``0})">
\r
647 Sort part of array in place using IntroSort
\r
649 <param name="a">Array to sort</param>
\r
650 <param name="f">Index of first position to sort</param>
\r
651 <param name="b">Index of first position beyond the part to sort</param>
\r
652 <param name="c">IComparer<T> to sort by</param>
\r
654 <member name="M:C5.Sorting.InsertionSort``1(``0[],System.Int32,System.Int32,C5.IComparer{``0})">
\r
656 Sort part of array in place using Insertion Sort
\r
658 <param name="a">Array to sort</param>
\r
659 <param name="f">Index of first position to sort</param>
\r
660 <param name="b">Index of first position beyond the part to sort</param>
\r
661 <param name="c">IComparer<T> to sort by</param>
\r
663 <member name="M:C5.Sorting.HeapSort``1(``0[],System.Int32,System.Int32,C5.IComparer{``0})">
\r
665 Sort part of array in place using Heap Sort
\r
667 <param name="a">Array to sort</param>
\r
668 <param name="f">Index of first position to sort</param>
\r
669 <param name="b">Index of first position beyond the part to sort</param>
\r
670 <param name="c">IComparer<T> to sort by</param>
\r
672 <member name="T:C5.C5Random">
\r
674 A modern random number generator based on (whatever)
\r
677 <member name="M:C5.C5Random.NextDouble">
\r
679 Get a new random System.Double value
\r
681 <returns>The random double</returns>
\r
683 <member name="M:C5.C5Random.Sample">
\r
685 Get a new random System.Double value
\r
687 <returns>The random double</returns>
\r
689 <member name="M:C5.C5Random.Next">
\r
691 Get a new random System.Int32 value
\r
693 <returns>The random int</returns>
\r
695 <member name="M:C5.C5Random.Next(System.Int32)">
\r
697 Get a random non-negative integer less than a given upper bound
\r
699 <param name="max">The upper bound (exclusive)</param>
\r
700 <returns></returns>
\r
702 <member name="M:C5.C5Random.Next(System.Int32,System.Int32)">
\r
704 Get a random integer between two given bounds
\r
706 <param name="min">The lower bound (inclusive)</param>
\r
707 <param name="max">The upper bound (exclusive)</param>
\r
708 <returns></returns>
\r
710 <member name="M:C5.C5Random.NextBytes(System.Byte[])">
\r
712 Fill a array of byte with random bytes
\r
714 <param name="buffer">The array to fill</param>
\r
716 <member name="M:C5.C5Random.#ctor">
\r
718 Create a random number generator seed by system time.
\r
721 <member name="M:C5.C5Random.#ctor(System.Int64)">
\r
723 Create a random number generator with a given seed
\r
725 <param name="seed">The seed</param>
\r
727 <member name="T:C5.TestedAttribute">
\r
729 A custom attribute to mark methods and properties as being tested
\r
730 sufficiently in the regression test suite.
\r
733 <member name="F:C5.TestedAttribute.via">
\r
735 Optional reference to test case
\r
738 <member name="M:C5.TestedAttribute.ToString">
\r
740 Pretty print attribute value
\r
742 <returns>"Tested via " + via</returns>
\r
744 <member name="T:C5.HashBag`1">
\r
746 A bag collection based on a hash table of (item,count) pairs.
\r
749 <member name="T:C5.ICollection`1">
\r
751 The simplest interface of a main stream generic collection
\r
752 with lookup, insertion and removal operations.
\r
755 <member name="T:C5.IExtensible`1">
\r
757 A generic collection to which one may add items. This is just the intersection
\r
758 of the main stream generic collection interfaces and the priority queue interface,
\r
759 <see cref="T:C5.ICollection!1"/> and <see cref="T:C5.IPriorityQueue!1"/>.
\r
762 <member name="M:C5.IExtensible`1.Add(`0)">
\r
764 Add an item to this collection if possible. If this collection has set
\r
765 semantics, the item will be added if not already in the collection. If
\r
766 bag semantics, the item will always be added.
\r
768 <param name="item">The item to add.</param>
\r
769 <returns>True if item was added.</returns>
\r
771 <member name="M:C5.IExtensible`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
773 Add the elements from another collection to this collection. If this
\r
774 collection has set semantics, only items not already in the collection
\r
777 <param name="items">The items to add.</param>
\r
779 <member name="M:C5.IExtensible`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
781 Add the elements from another collection with a more specialized item type
\r
782 to this collection. If this
\r
783 collection has set semantics, only items not already in the collection
\r
786 <typeparam name="U">The type of items to add</typeparam>
\r
787 <param name="items">The items to add</param>
\r
789 <member name="M:C5.IExtensible`1.Check">
\r
791 Check the integrity of the internal data structures of this collection.
\r
792 <p>This is only relevant for developers of the library</p>
\r
794 <returns>True if check was passed.</returns>
\r
796 <member name="P:C5.IExtensible`1.AllowsDuplicates">
\r
800 <value>False if this collection has set semantics, true if bag semantics.</value>
\r
802 <member name="P:C5.IExtensible`1.SyncRoot">
\r
806 <value>An object to be used for locking to enable multi threaded code
\r
807 to acces this collection safely.</value>
\r
809 <member name="P:C5.IExtensible`1.IsEmpty">
\r
813 <value>True if this collection is empty.</value>
\r
815 <member name="M:C5.ICollection`1.GetHashCode">
\r
817 The hashcode is defined as the sum of <code>h(item)</code> over the items
\r
818 of the collection, where the function <code>h</code> is???
\r
820 <returns>The unordered hashcode of this collection.</returns>
\r
822 <member name="M:C5.ICollection`1.Equals(C5.ICollection{`0})">
\r
824 Compare the contents of this collection to another one without regards to
\r
825 the sequence order. The comparison will use this collection's itemhasher
\r
826 to compare individual items.
\r
828 <param name="that">The collection to compare to.</param>
\r
829 <returns>True if this collection and that contains the same items.</returns>
\r
831 <member name="M:C5.ICollection`1.Contains(`0)">
\r
833 Check if this collection contains (an item equivalent to according to the
\r
834 itemhasher) a particular value.
\r
836 <param name="item">The value to check for.</param>
\r
837 <returns>True if the items is in this collection.</returns>
\r
839 <member name="M:C5.ICollection`1.ContainsCount(`0)">
\r
841 Count the number of items of the collection equal to a particular value.
\r
842 Returns 0 if and only if the value is not in the collection.
\r
844 <param name="item">The value to count.</param>
\r
845 <returns>The number of copies found.</returns>
\r
847 <member name="M:C5.ICollection`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
849 Check if this collection contains all the values in another collection.
\r
850 If this collection has bag semantics (<code>NoDuplicates==false</code>)
\r
851 the check is made with respect to multiplicities, else multiplicities
\r
852 are not taken into account.
\r
854 <param name="items">The </param>
\r
855 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
857 <member name="M:C5.ICollection`1.Find(`0@)">
\r
859 Check if this collection contains an item equivalent according to the
\r
860 itemhasher to a particular value. If so, return in the ref argument (a
\r
861 binary copy of) the actual value found.
\r
863 <param name="item">The value to look for.</param>
\r
864 <returns>True if the items is in this collection.</returns>
\r
866 <member name="M:C5.ICollection`1.FindOrAdd(`0@)">
\r
868 Check if this collection contains an item equivalent according to the
\r
869 itemhasher to a particular value. If so, return in the ref argument (a
\r
870 binary copy of) the actual value found. Else, add the item to the collection.
\r
872 <param name="item">The value to look for.</param>
\r
873 <returns>True if the item was found (hence not added).</returns>
\r
875 <member name="M:C5.ICollection`1.Update(`0)">
\r
877 Check if this collection contains an item equivalent according to the
\r
878 itemhasher to a particular value. If so, update the item in the collection
\r
879 to with a binary copy of the supplied value. If the collection has bag semantics,
\r
880 it is implementation dependent if this updates all equivalent copies in
\r
881 the collection or just one.
\r
883 <param name="item">Value to update.</param>
\r
884 <returns>True if the item was found and hence updated.</returns>
\r
886 <member name="M:C5.ICollection`1.UpdateOrAdd(`0)">
\r
888 Check if this collection contains an item equivalent according to the
\r
889 itemhasher to a particular value. If so, update the item in the collection
\r
890 to with a binary copy of the supplied value; else add the value to the collection.
\r
892 <param name="item">Value to add or update.</param>
\r
893 <returns>True if the item was found and updated (hence not added).</returns>
\r
895 <member name="M:C5.ICollection`1.Remove(`0)">
\r
897 Remove a particular item from this collection. If the collection has bag
\r
898 semantics only one copy equivalent to the supplied item is removed.
\r
900 <param name="item">The value to remove.</param>
\r
901 <returns>True if the item was found (and removed).</returns>
\r
903 <member name="M:C5.ICollection`1.RemoveWithReturn(`0@)">
\r
905 Remove a particular item from this collection if found. If the collection
\r
906 has bag semantics only one copy equivalent to the supplied item is removed,
\r
907 which one is implementation dependent.
\r
908 If an item was removed, report a binary copy of the actual item removed in
\r
911 <param name="item">The value to remove on input.</param>
\r
912 <returns>True if the item was found (and removed).</returns>
\r
914 <member name="M:C5.ICollection`1.RemoveAllCopies(`0)">
\r
916 Remove all items equivalent to a given value.
\r
918 <param name="item">The value to remove.</param>
\r
920 <member name="M:C5.ICollection`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
922 Remove all items in another collection from this one. If this collection
\r
923 has bag semantics, take multiplicities into account.
\r
925 <param name="items">The items to remove.</param>
\r
927 <member name="M:C5.ICollection`1.Clear">
\r
929 Remove all items from this collection.
\r
932 <member name="M:C5.ICollection`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
934 Remove all items not in some other collection from this one. If this collection
\r
935 has bag semantics, take multiplicities into account.
\r
937 <param name="items">The items to retain.</param>
\r
939 <member name="P:C5.ICollection`1.IsReadOnly">
\r
941 If true any call of an updating operation will throw an
\r
942 <code>InvalidOperationException</code>
\r
944 <value>True if this collection is read only.</value>
\r
946 <member name="P:C5.ICollection`1.ContainsSpeed">
\r
948 The value is symbolic indicating the type of asymptotic complexity
\r
949 in terms of the size of this collection (worst-case or amortized as
\r
952 <value>A characterization of the speed of lookup operations
\r
953 (<code>Contains()</code> etc.) of the implementation of this list.</value>
\r
955 <member name="M:C5.HashBag`1.#ctor">
\r
957 Create a hash bag with the deafult item hasher.
\r
960 <member name="M:C5.HashBag`1.#ctor(C5.IHasher{`0})">
\r
962 Create a hash bag with an external item hasher.
\r
964 <param name="h">The external hasher.</param>
\r
966 <member name="M:C5.HashBag`1.Contains(`0)">
\r
968 Check if an item is in the bag
\r
970 <param name="item">The item to look for</param>
\r
971 <returns>True if bag contains item</returns>
\r
973 <member name="M:C5.HashBag`1.Find(`0@)">
\r
975 Check if an item (collection equal to a given one) is in the bag and
\r
976 if so report the actual item object found.
\r
978 <param name="item">On entry, the item to look for.
\r
979 On exit the item found, if any</param>
\r
980 <returns>True if bag contains item</returns>
\r
982 <member name="M:C5.HashBag`1.Update(`0)">
\r
984 Check if an item (collection equal to a given one) is in the bag and
\r
985 if so replace the item object in the bag with the supplied one.
\r
987 <param name="item">The item object to update with</param>
\r
988 <returns>True if item was found (and updated)</returns>
\r
990 <member name="M:C5.HashBag`1.FindOrAdd(`0@)">
\r
992 Check if an item (collection equal to a given one) is in the bag.
\r
993 If found, report the actual item object in the bag,
\r
994 else add the supplied one.
\r
996 <param name="item">On entry, the item to look for or add.
\r
997 On exit the actual object found, if any.</param>
\r
998 <returns>True if item was found</returns>
\r
1000 <member name="M:C5.HashBag`1.UpdateOrAdd(`0)">
\r
1002 Check if an item (collection equal to a supplied one) is in the bag and
\r
1003 if so replace the item object in the set with the supplied one; else
\r
1004 add the supplied one.
\r
1006 <param name="item">The item to look for and update or add</param>
\r
1007 <returns>True if item was updated</returns>
\r
1009 <member name="M:C5.HashBag`1.Remove(`0)">
\r
1011 Remove one copy af an item from the bag
\r
1013 <param name="item">The item to remove</param>
\r
1014 <returns>True if item was (found and) removed </returns>
\r
1016 <member name="M:C5.HashBag`1.RemoveWithReturn(`0@)">
\r
1018 Remove one copy of an item from the bag, reporting the actual matching item object.
\r
1020 <param name="item">On entry the item to remove.
\r
1021 On exit, the actual removed item object.</param>
\r
1022 <returns>True if item was found.</returns>
\r
1024 <member name="M:C5.HashBag`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
1026 Remove all items in a supplied collection from this bag, counting multiplicities.
\r
1028 <param name="items">The items to remove.</param>
\r
1030 <member name="M:C5.HashBag`1.Clear">
\r
1032 Remove all items from the bag, resetting internal table to initial size.
\r
1035 <member name="M:C5.HashBag`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
1037 Remove all items *not* in a supplied collection from this bag,
\r
1038 counting multiplicities.
\r
1040 <param name="items">The items to retain</param>
\r
1042 <member name="M:C5.HashBag`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
1044 Check if all items in a supplied collection is in this bag
\r
1045 (counting multiplicities).
\r
1047 <param name="items">The items to look for.</param>
\r
1048 <returns>True if all items are found.</returns>
\r
1050 <member name="M:C5.HashBag`1.ToArray">
\r
1052 Create an array containing all items in this bag (in enumeration order).
\r
1054 <returns>The array</returns>
\r
1056 <member name="M:C5.HashBag`1.ContainsCount(`0)">
\r
1058 Count the number of times an item is in this set.
\r
1060 <param name="item">The item to look for.</param>
\r
1061 <returns>The count</returns>
\r
1063 <member name="M:C5.HashBag`1.RemoveAllCopies(`0)">
\r
1065 Remove all copies of item from this set.
\r
1067 <param name="item">The item to remove</param>
\r
1069 <member name="M:C5.HashBag`1.CopyTo(`0[],System.Int32)">
\r
1071 Copy the items of this bag to part of an array.
\r
1072 <exception cref="T:System.ArgumentOutOfRangeException"/> if i is negative.
\r
1073 <exception cref="T:System.ArgumentException"/> if the array does not have room for the items.
\r
1075 <param name="a">The array to copy to</param>
\r
1076 <param name="i">The starting index.</param>
\r
1078 <member name="M:C5.HashBag`1.Add(`0)">
\r
1080 Add an item to this bag.
\r
1082 <param name="item">The item to add.</param>
\r
1083 <returns>Always true</returns>
\r
1085 <member name="M:C5.HashBag`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
1087 Add all items of a collection to this set.
\r
1089 <param name="items">The items to add</param>
\r
1091 <member name="M:C5.HashBag`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
1093 Add the elements from another collection with a more specialized item type
\r
1094 to this collection.
\r
1096 <typeparam name="U">The type of items to add</typeparam>
\r
1097 <param name="items">The items to add</param>
\r
1099 <member name="M:C5.HashBag`1.GetEnumerator">
\r
1101 Create an enumerator for this bag.
\r
1103 <returns>The enumerator</returns>
\r
1105 <member name="M:C5.HashBag`1.Check">
\r
1107 Test internal structure of data (invariants)
\r
1109 <returns>True if pass</returns>
\r
1111 <member name="P:C5.HashBag`1.ContainsSpeed">
\r
1113 The complexity of the Contains operation
\r
1115 <value>Always returns Speed.Constant</value>
\r
1117 <member name="P:C5.HashBag`1.AllowsDuplicates">
\r
1119 Report if this is a set collection.
\r
1121 <value>Always true</value>
\r
1123 <member name="T:C5.Applier`1">
\r
1125 A generic delegate that when invoked performs some operation
\r
1129 <member name="T:C5.Mapper`2">
\r
1131 A generic delegate whose invocation constitutes a map from T to V.
\r
1134 <member name="T:C5.Filter`1">
\r
1136 A generic delegate that when invoked on a T item returns a boolean
\r
1137 value -- i.e. a T predicate.
\r
1140 <member name="T:C5.Speed">
\r
1142 The symbolic characterization of the speed of lookups for a collection.
\r
1143 The values may refer to worst-case, amortized and/or expected asymtotic
\r
1144 complexity wrt. the collection size.
\r
1147 <member name="F:C5.Speed.PotentiallyInfinite">
\r
1149 Counting the collection with the <code>Count property</code> may not return
\r
1150 (for a synthetic and potentially infinite collection).
\r
1153 <member name="F:C5.Speed.Linear">
\r
1155 Lookup operations like <code>Contains(T item)</code> or the <code>Count</code>
\r
1156 property may take time O(n),
\r
1157 where n is the size of the collection.
\r
1160 <member name="F:C5.Speed.Log">
\r
1162 Lookup operations like <code>Contains(T item)</code> or the <code>Count</code>
\r
1163 property takes time O(log n),
\r
1164 where n is the size of the collection.
\r
1167 <member name="F:C5.Speed.Constant">
\r
1169 Lookup operations like <code>Contains(T item)</code> or the <code>Count</code>
\r
1170 property takes time O(1),
\r
1171 where n is the size of the collection.
\r
1174 <member name="T:C5.ISequenced`1">
\r
1176 An editable collection maintaining a definite sequence order of the items.
\r
1178 <p>Implementations of this interface must compute the hash code and
\r
1179 equality exactly as prescribed in the method definitions in order to
\r
1180 be consistent with other collection classes implementing this interface.</p>
\r
1181 <p>This interface is usually implemented by explicit interface implementation,
\r
1182 not as ordinary virtual methods.</p>
\r
1185 <member name="M:C5.ISequenced`1.GetHashCode">
\r
1187 The hashcode is defined as <code>h(...h(h(x1),x2)...,xn)</code> for
\r
1188 <code>h(a,b)=31*a+b</code> and the x's the hash codes of
\r
1190 <returns>The sequence order hashcode of this collection.</returns>
\r
1192 <member name="M:C5.ISequenced`1.Equals(C5.ISequenced{`0})">
\r
1194 Compare this sequenced collection to another one in sequence order.
\r
1196 <param name="that">The sequenced collection to compare to.</param>
\r
1197 <returns>True if this collection and that contains equal (according to
\r
1198 this collection's itemhasher) in the same sequence order.</returns>
\r
1200 <member name="T:C5.IIndexed`1">
\r
1202 A sequenced collection, where indices of items in the order are maintained
\r
1205 <member name="M:C5.IIndexed`1.IndexOf(`0)">
\r
1207 Searches for an item in the list going forwrds from the start.
\r
1209 <param name="item">Item to search for.</param>
\r
1210 <returns>Index of item from start.</returns>
\r
1212 <member name="M:C5.IIndexed`1.LastIndexOf(`0)">
\r
1214 Searches for an item in the list going backwords from the end.
\r
1216 <param name="item">Item to search for.</param>
\r
1217 <returns>Index of of item from the end.</returns>
\r
1219 <member name="M:C5.IIndexed`1.RemoveAt(System.Int32)">
\r
1221 Remove the item at a specific position of the list.
\r
1222 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
1223 >= the size of the collection.
\r
1225 <param name="i">The index of the item to remove.</param>
\r
1226 <returns>The removed item.</returns>
\r
1228 <member name="M:C5.IIndexed`1.RemoveInterval(System.Int32,System.Int32)">
\r
1230 Remove all items in an index interval.
\r
1231 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
1233 <param name="start">The index of the first item to remove.</param>
\r
1234 <param name="count">The number of items to remove.</param>
\r
1236 <member name="P:C5.IIndexed`1.Item(System.Int32)">
\r
1238 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
1239 >= the size of the collection.
\r
1241 <value>The i'th item of this list.</value>
\r
1242 <param name="i">the index to lookup</param>
\r
1244 <member name="P:C5.IIndexed`1.Item(System.Int32,System.Int32)">
\r
1246 <exception cref="T:System.IndexOutOfRangeException"/>.
\r
1248 <value>The directed collection of items in a specific index interval.</value>
\r
1249 <param name="start">The low index of the interval (inclusive).</param>
\r
1250 <param name="count">The size of the range.</param>
\r
1252 <member name="T:C5.IStack`1">
\r
1254 The interface describing the operations of a LIFO stack data structure.
\r
1256 <typeparam name="T">The item type</typeparam>
\r
1258 <member name="M:C5.IStack`1.Push(`0)">
\r
1260 Push an item to the top of the stack.
\r
1262 <param name="item">The item</param>
\r
1264 <member name="M:C5.IStack`1.Pop">
\r
1266 Pop the item at the top of the stack from the stack.
\r
1268 <returns>The popped item.</returns>
\r
1270 <member name="T:C5.IQueue`1">
\r
1272 The interface describing the operations of a FIFO queue data structure.
\r
1274 <typeparam name="T">The item type</typeparam>
\r
1276 <member name="M:C5.IQueue`1.EnQueue(`0)">
\r
1278 Enqueue an item at the back of the queue.
\r
1280 <param name="item">The item</param>
\r
1282 <member name="M:C5.IQueue`1.DeQueue">
\r
1284 Dequeue an item from the front of the queue.
\r
1286 <returns>The item</returns>
\r
1288 <member name="T:C5.IList`1">
\r
1290 This is an indexed collection, where the item order is chosen by
\r
1291 the user at insertion time.
\r
1293 NBNBNB: we neeed a description of the view functionality here!
\r
1296 <member name="M:C5.IList`1.Insert(System.Int32,`0)">
\r
1298 Insert an item at a specific index location in this list.
\r
1299 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
1300 > the size of the collection.</summary>
\r
1301 <exception cref="T:System.InvalidOperationException"/> if the list has
\r
1302 <code>NoDuplicates=true</code> and the item is
\r
1303 already in the list.
\r
1304 <param name="i">The index at which to insert.</param>
\r
1305 <param name="item">The item to insert.</param>
\r
1307 <member name="M:C5.IList`1.InsertFirst(`0)">
\r
1309 Insert an item at the front of this list.
\r
1310 <exception cref="T:System.InvalidOperationException"/> if the list has
\r
1311 <code>NoDuplicates=true</code> and the item is
\r
1312 already in the list.
\r
1314 <param name="item">The item to insert.</param>
\r
1316 <member name="M:C5.IList`1.InsertLast(`0)">
\r
1318 Insert an item at the back of this list.
\r
1319 <exception cref="T:System.InvalidOperationException"/> if the list has
\r
1320 <code>NoDuplicates=true</code> and the item is
\r
1321 already in the list.
\r
1323 <param name="item">The item to insert.</param>
\r
1325 <member name="M:C5.IList`1.InsertBefore(`0,`0)">
\r
1327 Insert an item right before the first occurrence of some target item.
\r
1328 <exception cref="T:System.InvalidOperationException"/> if target is not found
\r
1329 or if the list has <code>NoDuplicates=true</code> and the item is
\r
1330 already in the list.
\r
1332 <param name="item">The item to insert.</param>
\r
1333 <param name="target">The target before which to insert.</param>
\r
1335 <member name="M:C5.IList`1.InsertAfter(`0,`0)">
\r
1337 Insert an item right after the last(???) occurrence of some target item.
\r
1338 <exception cref="T:System.InvalidOperationException"/> if target is not found
\r
1339 or if the list has <code>NoDuplicates=true</code> and the item is
\r
1340 already in the list.
\r
1342 <param name="item">The item to insert.</param>
\r
1343 <param name="target">The target after which to insert.</param>
\r
1345 <member name="M:C5.IList`1.InsertAll(System.Int32,System.Collections.Generic.IEnumerable{`0})">
\r
1347 Insert into this list all items from an enumerable collection starting
\r
1348 at a particular index.
\r
1349 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
1350 > the size of the collection.
\r
1351 <exception cref="T:System.InvalidOperationException"/> if the list has
\r
1352 <code>NoDuplicates=true</code> and one of the items to insert is
\r
1353 already in the list.
\r
1355 <param name="i">Index to start inserting at</param>
\r
1356 <param name="items">Items to insert</param>
\r
1358 <member name="M:C5.IList`1.FindAll(C5.Filter{`0})">
\r
1360 Create a new list consisting of the items of this list satisfying a
\r
1361 certain predicate.
\r
1363 <param name="filter">The filter delegate defining the predicate.</param>
\r
1364 <returns>The new list.</returns>
\r
1366 <member name="M:C5.IList`1.Map``1(C5.Mapper{`0,``0})">
\r
1368 Create a new list consisting of the results of mapping all items of this
\r
1369 list. The new list will use the default hasher for the item type V.
\r
1371 <typeparam name="V">The type of items of the new list</typeparam>
\r
1372 <param name="mapper">The delegate defining the map.</param>
\r
1373 <returns>The new list.</returns>
\r
1375 <member name="M:C5.IList`1.Map``1(C5.Mapper{`0,``0},C5.IHasher{``0})">
\r
1377 Create a new list consisting of the results of mapping all items of this
\r
1378 list. The new list will use a specified hasher for the item type.
\r
1380 <typeparam name="V">The type of items of the new list</typeparam>
\r
1381 <param name="mapper">The delegate defining the map.</param>
\r
1382 <param name="hasher">The hasher to use for the new list</param>
\r
1383 <returns>The new list.</returns>
\r
1385 <member name="M:C5.IList`1.Remove">
\r
1387 Remove one item from the list: from the front if <code>FIFO</code>
\r
1388 is true, else from the back.
\r
1389 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
1391 <returns>The removed item.</returns>
\r
1393 <member name="M:C5.IList`1.RemoveFirst">
\r
1395 Remove one item from the fromnt of the list.
\r
1396 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
1398 <returns>The removed item.</returns>
\r
1400 <member name="M:C5.IList`1.RemoveLast">
\r
1402 Remove one item from the back of the list.
\r
1403 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
1405 <returns>The removed item.</returns>
\r
1407 <member name="M:C5.IList`1.View(System.Int32,System.Int32)">
\r
1409 Create a list view on this list.
\r
1410 <exception cref="T:System.ArgumentOutOfRangeException"/> if the view would not fit into
\r
1413 <param name="start">The index in this list of the start of the view.</param>
\r
1414 <param name="count">The size of the view.</param>
\r
1415 <returns>The new list view.</returns>
\r
1417 <member name="M:C5.IList`1.Slide(System.Int32)">
\r
1419 Slide this list view along the underlying list.
\r
1420 <exception cref="T:System.InvalidOperationException"/> if this list is not a view.
\r
1421 <exception cref="T:System.ArgumentOutOfRangeException"/> if the operation
\r
1422 would bring either end of the view outside the underlying list.
\r
1424 <param name="offset">The signed amount to slide: positive to slide
\r
1425 towards the end.</param>
\r
1427 <member name="M:C5.IList`1.Slide(System.Int32,System.Int32)">
\r
1429 Slide this list view along the underlying list, changing its size.
\r
1430 <exception cref="T:System.InvalidOperationException"/> if this list is not a view.
\r
1431 <exception cref="T:System.ArgumentOutOfRangeException"/> if the operation
\r
1432 would bring either end of the view outside the underlying list.
\r
1434 <param name="offset">The signed amount to slide: positive to slide
\r
1435 towards the end.</param>
\r
1436 <param name="size">The new size of the view.</param>
\r
1438 <member name="M:C5.IList`1.Reverse">
\r
1440 Reverse the list so the items are in the opposite sequence order.
\r
1443 <member name="M:C5.IList`1.Reverse(System.Int32,System.Int32)">
\r
1445 Reverst part of the list so the items are in the opposite sequence order.
\r
1446 <exception cref="T:System.ArgumentException"/> if the count is negative.
\r
1447 <exception cref="T:System.ArgumentOutOfRangeException"/> if the part does not fit
\r
1450 <param name="start">The index of the start of the part to reverse.</param>
\r
1451 <param name="count">The size of the part to reverse.</param>
\r
1453 <member name="M:C5.IList`1.IsSorted(C5.IComparer{`0})">
\r
1455 Check if this list is sorted according to a specific sorting order.
\r
1457 <param name="c">The comparer defining the sorting order.</param>
\r
1458 <returns>True if the list is sorted, else false.</returns>
\r
1460 <member name="M:C5.IList`1.Sort(C5.IComparer{`0})">
\r
1462 Sort the items of the list according to a specific sorting order.
\r
1464 <param name="c">The comparer defining the sorting order.</param>
\r
1466 <member name="M:C5.IList`1.Shuffle">
\r
1468 Randonmly shuffle the items of this list.
\r
1471 <member name="M:C5.IList`1.Shuffle(System.Random)">
\r
1473 Shuffle the items of this list according to a specific random source.
\r
1475 <param name="rnd">The random source.</param>
\r
1477 <member name="P:C5.IList`1.First">
\r
1479 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
1481 <value>The first item in this list.</value>
\r
1483 <member name="P:C5.IList`1.Last">
\r
1485 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
1487 <value>The last item in this list.</value>
\r
1489 <member name="P:C5.IList`1.FIFO">
\r
1491 Since <code>Add(T item)</code> always add at the end of the list,
\r
1492 this describes if list has FIFO or LIFO semantics.
\r
1494 <value>True if the <code>Remove()</code> operation removes from the
\r
1495 start of the list, false if it removes from the end.</value>
\r
1497 <member name="P:C5.IList`1.Item(System.Int32)">
\r
1499 On this list, this indexer is read/write.
\r
1500 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
1501 >= the size of the collection.
\r
1503 <value>The i'th item of this list.</value>
\r
1504 <param name="i">The index of the item to fetch or store.</param>
\r
1506 <member name="P:C5.IList`1.Underlying">
\r
1508 Null if this list is not a view.
\r
1510 <value>Underlying list for view.</value>
\r
1512 <member name="P:C5.IList`1.Offset">
\r
1515 <value>Offset for this list view or 0 for an underlying list.</value>
\r
1517 <member name="T:C5.IPriorityQueue`1">
\r
1519 A generic collection of items prioritized by a comparison (order) relation.
\r
1520 Supports adding items and reporting or removing extremal elements.
\r
1521 The priority queue itself exports the used
\r
1522 order relation through its implementation of <code>IComparer<T></code>
\r
1525 <member name="M:C5.IPriorityQueue`1.FindMin">
\r
1527 Find the current least item of this priority queue.
\r
1529 <returns>The least item.</returns>
\r
1531 <member name="M:C5.IPriorityQueue`1.DeleteMin">
\r
1533 Remove the least item from this priority queue.
\r
1535 <returns>The removed item.</returns>
\r
1537 <member name="M:C5.IPriorityQueue`1.FindMax">
\r
1539 Find the current largest item of this priority queue.
\r
1541 <returns>The largest item.</returns>
\r
1543 <member name="M:C5.IPriorityQueue`1.DeleteMax">
\r
1545 Remove the largest item from this priority queue.
\r
1547 <returns>The removed item.</returns>
\r
1549 <member name="P:C5.IPriorityQueue`1.Comparer">
\r
1551 The comparer object supplied at creation time for this collection
\r
1553 <value>The comparer</value>
\r
1555 <member name="T:C5.ISorted`1">
\r
1557 A collection where items are maintained in sorted order.
\r
1560 <member name="M:C5.ISorted`1.Predecessor(`0)">
\r
1562 Find the strict predecessor in the sorted collection of a particular value,
\r
1563 i.e. the largest item in the collection less than the supplied value.
\r
1564 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
1565 supplied value is less than or equal to the minimum of this collection.)
\r
1567 <param name="item">The item to find the predecessor for.</param>
\r
1568 <returns>The predecessor.</returns>
\r
1570 <member name="M:C5.ISorted`1.Successor(`0)">
\r
1572 Find the strict successor in the sorted collection of a particular value,
\r
1573 i.e. the least item in the collection greater than the supplied value.
\r
1574 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
1575 supplied value is greater than or equal to the maximum of this collection.)
\r
1577 <param name="item">The item to find the successor for.</param>
\r
1578 <returns>The successor.</returns>
\r
1580 <member name="M:C5.ISorted`1.WeakPredecessor(`0)">
\r
1582 Find the weak predecessor in the sorted collection of a particular value,
\r
1583 i.e. the largest item in the collection less than or equal to the supplied value.
\r
1584 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
1585 supplied value is less than the minimum of this collection.)
\r
1587 <param name="item">The item to find the weak predecessor for.</param>
\r
1588 <returns>The weak predecessor.</returns>
\r
1590 <member name="M:C5.ISorted`1.WeakSuccessor(`0)">
\r
1592 Find the weak successor in the sorted collection of a particular value,
\r
1593 i.e. the least item in the collection greater than or equal to the supplied value.
\r
1594 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
1595 supplied value is greater than the maximum of this collection.)
\r
1597 <param name="item">The item to find the weak successor for.</param>
\r
1598 <returns>The weak successor.</returns>
\r
1600 <member name="M:C5.ISorted`1.Cut(System.IComparable{`0},`0@,System.Boolean@,`0@,System.Boolean@)">
\r
1602 Perform a search in the sorted collection for the ranges in which a
\r
1603 non-decreasing function from the item type to <code>int</code> is
\r
1604 negative, zero respectively positive. If the supplied cut function is
\r
1605 not non-decreasing, the result of this call is undefined.
\r
1607 <param name="c">The cut function <code>T</code> to <code>int</code>, given
\r
1608 as an <code>IComparable<T></code> object, where the cut function is
\r
1609 the <code>c.CompareTo(T that)</code> method.</param>
\r
1610 <param name="low">Returns the largest item in the collection, where the
\r
1611 cut function is negative (if any).</param>
\r
1612 <param name="lowIsValid">True if the cut function is negative somewhere
\r
1613 on this collection.</param>
\r
1614 <param name="high">Returns the least item in the collection, where the
\r
1615 cut function is positive (if any).</param>
\r
1616 <param name="highIsValid">True if the cut function is positive somewhere
\r
1617 on this collection.</param>
\r
1618 <returns></returns>
\r
1620 <member name="M:C5.ISorted`1.RangeFrom(`0)">
\r
1622 Query this sorted collection for items greater than or equal to a supplied value.
\r
1624 <param name="bot">The lower bound (inclusive).</param>
\r
1625 <returns>The result directed collection.</returns>
\r
1627 <member name="M:C5.ISorted`1.RangeFromTo(`0,`0)">
\r
1629 Query this sorted collection for items between two supplied values.
\r
1631 <param name="bot">The lower bound (inclusive).</param>
\r
1632 <param name="top">The upper bound (exclusive).</param>
\r
1633 <returns>The result directed collection.</returns>
\r
1635 <member name="M:C5.ISorted`1.RangeTo(`0)">
\r
1637 Query this sorted collection for items less than a supplied value.
\r
1639 <param name="top">The upper bound (exclusive).</param>
\r
1640 <returns>The result directed collection.</returns>
\r
1642 <member name="M:C5.ISorted`1.RangeAll">
\r
1644 Create a directed collection with the same items as this collection.
\r
1646 <returns>The result directed collection.</returns>
\r
1648 <member name="M:C5.ISorted`1.AddSorted(System.Collections.Generic.IEnumerable{`0})">
\r
1650 Add all the items from another collection with an enumeration order that
\r
1651 is increasing in the items.
\r
1652 <exception cref="T:System.ArgumentException"/> if the enumerated items turns out
\r
1653 not to be in increasing order.
\r
1655 <param name="items">The collection to add.</param>
\r
1657 <member name="M:C5.ISorted`1.RemoveRangeFrom(`0)">
\r
1659 Remove all items of this collection above or at a supplied threshold.
\r
1661 <param name="low">The lower threshold (inclusive).</param>
\r
1663 <member name="M:C5.ISorted`1.RemoveRangeFromTo(`0,`0)">
\r
1665 Remove all items of this collection between two supplied thresholds.
\r
1667 <param name="low">The lower threshold (inclusive).</param>
\r
1668 <param name="hi">The upper threshold (exclusive).</param>
\r
1670 <member name="M:C5.ISorted`1.RemoveRangeTo(`0)">
\r
1672 Remove all items of this collection below a supplied threshold.
\r
1674 <param name="hi">The upper threshold (exclusive).</param>
\r
1676 <member name="T:C5.IIndexedSorted`1">
\r
1678 A collection where items are maintained in sorted order together
\r
1679 with their indexes in that order.
\r
1682 <member name="M:C5.IIndexedSorted`1.CountFrom(`0)">
\r
1684 Determine the number of items at or above a supplied threshold.
\r
1686 <param name="bot">The lower bound (inclusive)</param>
\r
1687 <returns>The number of matcing items.</returns>
\r
1689 <member name="M:C5.IIndexedSorted`1.CountFromTo(`0,`0)">
\r
1691 Determine the number of items between two supplied thresholds.
\r
1693 <param name="bot">The lower bound (inclusive)</param>
\r
1694 <param name="top">The upper bound (exclusive)</param>
\r
1695 <returns>The number of matcing items.</returns>
\r
1697 <member name="M:C5.IIndexedSorted`1.CountTo(`0)">
\r
1699 Determine the number of items below a supplied threshold.
\r
1701 <param name="top">The upper bound (exclusive)</param>
\r
1702 <returns>The number of matcing items.</returns>
\r
1704 <member name="M:C5.IIndexedSorted`1.RangeFrom(`0)">
\r
1706 Query this sorted collection for items greater than or equal to a supplied value.
\r
1708 <param name="bot">The lower bound (inclusive).</param>
\r
1709 <returns>The result directed collection.</returns>
\r
1711 <member name="M:C5.IIndexedSorted`1.RangeFromTo(`0,`0)">
\r
1713 Query this sorted collection for items between two supplied values.
\r
1715 <param name="bot">The lower bound (inclusive).</param>
\r
1716 <param name="top">The upper bound (exclusive).</param>
\r
1717 <returns>The result directed collection.</returns>
\r
1719 <member name="M:C5.IIndexedSorted`1.RangeTo(`0)">
\r
1721 Query this sorted collection for items less than a supplied value.
\r
1723 <param name="top">The upper bound (exclusive).</param>
\r
1724 <returns>The result directed collection.</returns>
\r
1726 <member name="M:C5.IIndexedSorted`1.FindAll(C5.Filter{`0})">
\r
1728 Create a new indexed sorted collection consisting of the items of this
\r
1729 indexed sorted collection satisfying a certain predicate.
\r
1731 <param name="f">The filter delegate defining the predicate.</param>
\r
1732 <returns>The new indexed sorted collection.</returns>
\r
1734 <member name="M:C5.IIndexedSorted`1.Map``1(C5.Mapper{`0,``0},C5.IComparer{``0})">
\r
1736 Create a new indexed sorted collection consisting of the results of
\r
1737 mapping all items of this list.
\r
1738 <exception cref="T:System.ArgumentException"/> if the map is not increasing over
\r
1739 the items of this collection (with respect to the two given comparison
\r
1742 <param name="m">The delegate definging the map.</param>
\r
1743 <param name="c">The comparion relation to use for the result.</param>
\r
1744 <returns>The new sorted collection.</returns>
\r
1746 <member name="T:C5.IPersistentSorted`1">
\r
1748 The type of a sorted collection with persistence
\r
1751 <member name="M:C5.IPersistentSorted`1.Snapshot">
\r
1753 Make a (read-only) snap shot of this collection.
\r
1755 <returns>The snap shot.</returns>
\r
1757 <member name="T:C5.IDictionary`2">
\r
1759 A dictionary with keys of type K and values of type V. Equivalent to a
\r
1760 finite partial map from K to V.
\r
1763 <member name="M:C5.IDictionary`2.Add(`0,`1)">
\r
1765 Add a new (key, value) pair (a mapping) to the dictionary.
\r
1766 <exception cref="T:System.InvalidOperationException"/> if there already is an entry with the same key.
\r
1768 <param name="key">Key to add</param>
\r
1769 <param name="val">Value to add</param>
\r
1771 <member name="M:C5.IDictionary`2.Remove(`0)">
\r
1773 Remove an entry with a given key from the dictionary
\r
1775 <param name="key">The key of the entry to remove</param>
\r
1776 <returns>True if an entry was found (and removed)</returns>
\r
1778 <member name="M:C5.IDictionary`2.Remove(`0,`1@)">
\r
1780 Remove an entry with a given key from the dictionary and report its value.
\r
1782 <param name="key">The key of the entry to remove</param>
\r
1783 <param name="val">On exit, the value of the removed entry</param>
\r
1784 <returns>True if an entry was found (and removed)</returns>
\r
1786 <member name="M:C5.IDictionary`2.Clear">
\r
1788 Remove all entries from the dictionary
\r
1791 <member name="M:C5.IDictionary`2.Contains(`0)">
\r
1793 Check if there is an entry with a specified key
\r
1795 <param name="key">The key to look for</param>
\r
1796 <returns>True if key was found</returns>
\r
1798 <member name="M:C5.IDictionary`2.Find(`0,`1@)">
\r
1800 Check if there is an entry with a specified key and report the corresponding
\r
1801 value if found. This can be seen as a safe form of "val = this[key]".
\r
1803 <param name="key">The key to look for</param>
\r
1804 <param name="val">On exit, the value of the entry</param>
\r
1805 <returns>True if key was found</returns>
\r
1807 <member name="M:C5.IDictionary`2.Update(`0,`1)">
\r
1809 Look for a specific key in the dictionary and if found replace the value with a new one.
\r
1810 This can be seen as a non-adding version of "this[key] = val".
\r
1812 <param name="key">The key to look for</param>
\r
1813 <param name="val">The new value</param>
\r
1814 <returns>True if key was found</returns>
\r
1816 <member name="M:C5.IDictionary`2.FindOrAdd(`0,`1@)">
\r
1818 Look for a specific key in the dictionary. If found, report the corresponding value,
\r
1819 else add an entry with the key and the supplied value.
\r
1821 <param name="key">The key to look for</param>
\r
1822 <param name="val">On entry the value to add if the key is not found.
\r
1823 On exit the value found if any.</param>
\r
1824 <returns>True if key was found</returns>
\r
1826 <member name="M:C5.IDictionary`2.UpdateOrAdd(`0,`1)">
\r
1828 Update value in dictionary corresponding to key if found, else add new entry.
\r
1829 More general than "this[key] = val;" by reporting if key was found.
\r
1831 <param name="key">The key to look for</param>
\r
1832 <param name="val">The value to add or replace with.</param>
\r
1833 <returns>True if key was found and value updated.</returns>
\r
1835 <member name="M:C5.IDictionary`2.Check">
\r
1837 Check the integrity of the internal data structures of this dictionary.
\r
1838 Only avaliable in DEBUG builds???
\r
1840 <returns>True if check does not fail.</returns>
\r
1842 <member name="P:C5.IDictionary`2.Item(`0)">
\r
1844 Indexer for dictionary.
\r
1845 <exception cref="T:System.InvalidOperationException"/> if no entry is found.
\r
1847 <value>The value corresponding to the key</value>
\r
1849 <member name="P:C5.IDictionary`2.Count">
\r
1853 <value>The number of entrues in the dictionary</value>
\r
1855 <member name="P:C5.IDictionary`2.IsReadOnly">
\r
1859 <value>True if dictionary is read only</value>
\r
1861 <member name="P:C5.IDictionary`2.SyncRoot">
\r
1865 <value>The distinguished object to use for locking to synchronize multithreaded access</value>
\r
1867 <member name="P:C5.IDictionary`2.Keys">
\r
1871 <value>A collection containg the all the keys of the dictionary</value>
\r
1873 <member name="P:C5.IDictionary`2.Values">
\r
1877 <value>A collection containing all the values of the dictionary</value>
\r
1879 <member name="T:C5.ISortedDictionary`2">
\r
1881 A dictionary with sorted keys.
\r
1884 <member name="M:C5.ISortedDictionary`2.Predecessor(`0)">
\r
1886 Find the entry with the largest key less than a given key.
\r
1887 <exception cref="T:System.InvalidOperationException"/> if there is no such entry.
\r
1889 <param name="key">The key to compare to</param>
\r
1890 <returns>The entry</returns>
\r
1892 <member name="M:C5.ISortedDictionary`2.Successor(`0)">
\r
1894 Find the entry with the least key greater than a given key.
\r
1895 <exception cref="T:System.InvalidOperationException"/> if there is no such entry.
\r
1897 <param name="key">The key to compare to</param>
\r
1898 <returns>The entry</returns>
\r
1900 <member name="M:C5.ISortedDictionary`2.WeakPredecessor(`0)">
\r
1902 Find the entry with the largest key less than or equal to a given key.
\r
1903 <exception cref="T:System.InvalidOperationException"/> if there is no such entry.
\r
1905 <param name="key">The key to compare to</param>
\r
1906 <returns>The entry</returns>
\r
1908 <member name="M:C5.ISortedDictionary`2.WeakSuccessor(`0)">
\r
1910 Find the entry with the least key greater than or equal to a given key.
\r
1911 <exception cref="T:System.InvalidOperationException"/> if there is no such entry.
\r
1913 <param name="key">The key to compare to</param>
\r
1914 <returns>The entry</returns>
\r
1916 <member name="T:C5.TreeBag`1">
\r
1918 An implementation of Red-Black trees as an indexed, sorted collection with bag semantics,
\r
1919 cf. <a href="litterature.htm#CLRS">CLRS</a>. (<see cref="T:C5.TreeBag!1"/> for an
\r
1920 implementation with set semantics).
\r
1922 The comparer (sorting order) may be either natural, because the item type is comparable
\r
1923 (generic: <see cref="T:C5.IComparable!1"/> or non-generic: System.IComparable) or it can
\r
1924 be external and supplied by the user in the constructor.
\r
1926 Each distinct item is only kept in one place in the tree - together with the number
\r
1927 of times it is a member of the bag. Thus, if two items that are equal according
\r
1930 <member name="M:C5.TreeBag`1.left(C5.TreeBag{`0}.Node)">
\r
1932 Fetch the left child of n taking node-copying persistence into
\r
1933 account if relevant.
\r
1935 <param name="n"></param>
\r
1936 <returns></returns>
\r
1938 <member name="M:C5.TreeBag`1.#ctor">
\r
1940 Create a red-black tree collection with natural comparer and item hasher.
\r
1943 <member name="M:C5.TreeBag`1.#ctor(C5.IComparer{`0})">
\r
1945 Create a red-black tree collection with an external comparer (and natural item hasher,
\r
1946 assumed consistent).
\r
1948 <param name="c">The external comparer</param>
\r
1950 <member name="M:C5.TreeBag`1.#ctor(C5.IComparer{`0},C5.IHasher{`0})">
\r
1952 Create a red-black tree collection with an external comparer aand an external
\r
1953 item hasher, assumed consistent.
\r
1955 <param name="c">The external comparer</param>
\r
1956 <param name="h">The external item hasher</param>
\r
1958 <member name="M:C5.TreeBag`1.GetEnumerator">
\r
1960 Create an enumerator for this tree
\r
1962 <returns>The enumerator</returns>
\r
1964 <member name="M:C5.TreeBag`1.addIterative(`0,`0@,System.Boolean,System.Boolean@)">
\r
1966 Add item to tree. If already there, return the found item in the second argument.
\r
1968 <param name="item">Item to add</param>
\r
1969 <param name="founditem">item found</param>
\r
1970 <param name="update">whether item in node should be updated</param>
\r
1971 <param name="wasfound">true if found in bag, false if not found or tre is a set</param>
\r
1972 <returns>True if item was added</returns>
\r
1974 <member name="M:C5.TreeBag`1.Add(`0)">
\r
1976 Add an item to this collection if possible. If this collection has set
\r
1977 semantics, the item will be added if not already in the collection. If
\r
1978 bag semantics, the item will always be added.
\r
1980 <param name="item">The item to add.</param>
\r
1981 <returns>True if item was added.</returns>
\r
1983 <member name="M:C5.TreeBag`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
1985 Add the elements from another collection to this collection. If this
\r
1986 collection has set semantics, only items not already in the collection
\r
1989 <param name="items">The items to add.</param>
\r
1991 <member name="M:C5.TreeBag`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
1993 Add the elements from another collection with a more specialized item type
\r
1994 to this collection. If this
\r
1995 collection has set semantics, only items not already in the collection
\r
1998 <typeparam name="U">The type of items to add</typeparam>
\r
1999 <param name="items">The items to add</param>
\r
2001 <member name="M:C5.TreeBag`1.AddSorted(System.Collections.Generic.IEnumerable{`0})">
\r
2003 Add all the items from another collection with an enumeration order that
\r
2004 is increasing in the items. <para>The idea is that the implementation may use
\r
2005 a faster algorithm to merge the two collections.</para>
\r
2006 <exception cref="T:System.ArgumentException"/> if the enumerated items turns out
\r
2007 not to be in increasing order.
\r
2009 <param name="items">The collection to add.</param>
\r
2011 <member name="M:C5.TreeBag`1.Contains(`0)">
\r
2013 Check if this collection contains (an item equivalent to according to the
\r
2014 itemhasher) a particular value.
\r
2016 <param name="item">The value to check for.</param>
\r
2017 <returns>True if the items is in this collection.</returns>
\r
2019 <member name="M:C5.TreeBag`1.Find(`0@)">
\r
2021 Check if this collection contains an item equivalent according to the
\r
2022 itemhasher to a particular value. If so, return in the ref argument (a
\r
2023 binary copy of) the actual value found.
\r
2025 <param name="item">The value to look for.</param>
\r
2026 <returns>True if the items is in this collection.</returns>
\r
2028 <member name="M:C5.TreeBag`1.FindOrAdd(`0@)">
\r
2030 Find or add the item to the tree. If the tree does not contain
\r
2031 an item equivalent to this item add it, else return the exisiting
\r
2032 one in the ref argument.
\r
2035 <param name="item"></param>
\r
2036 <returns>True if item was found</returns>
\r
2038 <member name="M:C5.TreeBag`1.Update(`0)">
\r
2040 Check if this collection contains an item equivalent according to the
\r
2041 itemhasher to a particular value. If so, update the item in the collection
\r
2042 to with a binary copy of the supplied value. If the collection has bag semantics,
\r
2043 this updates all equivalent copies in
\r
2046 <param name="item">Value to update.</param>
\r
2047 <returns>True if the item was found and hence updated.</returns>
\r
2049 <member name="M:C5.TreeBag`1.UpdateOrAdd(`0)">
\r
2051 Check if this collection contains an item equivalent according to the
\r
2052 itemhasher to a particular value. If so, update the item in the collection
\r
2053 to with a binary copy of the supplied value; else add the value to the collection.
\r
2055 <p>NOTE: the bag implementation is currently wrong!</p>
\r
2057 <param name="item">Value to add or update.</param>
\r
2058 <returns>True if the item was found and updated (hence not added).</returns>
\r
2060 <member name="M:C5.TreeBag`1.Remove(`0)">
\r
2062 Remove a particular item from this collection. If the collection has bag
\r
2063 semantics only one copy equivalent to the supplied item is removed.
\r
2065 <param name="item">The value to remove.</param>
\r
2066 <returns>True if the item was found (and removed).</returns>
\r
2068 <member name="M:C5.TreeBag`1.RemoveWithReturn(`0@)">
\r
2070 Remove a particular item from this collection if found. If the collection
\r
2071 has bag semantics only one copy equivalent to the supplied item is removed,
\r
2072 which one is implementation dependent.
\r
2073 If an item was removed, report a binary copy of the actual item removed in
\r
2076 <param name="item">The value to remove on input.</param>
\r
2077 <returns>True if the item was found (and removed).</returns>
\r
2079 <member name="M:C5.TreeBag`1.Clear">
\r
2081 Remove all items from this collection.
\r
2084 <member name="M:C5.TreeBag`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
2086 Remove all items in another collection from this one. If this collection
\r
2087 has bag semantics, take multiplicities into account.
\r
2089 <param name="items">The items to remove.</param>
\r
2091 <member name="M:C5.TreeBag`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
2093 Remove all items not in some other collection from this one. If this collection
\r
2094 has bag semantics, take multiplicities into account.
\r
2096 <param name="items">The items to retain.</param>
\r
2098 <member name="M:C5.TreeBag`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
2100 Check if this collection contains all the values in another collection.
\r
2101 If this collection has bag semantics (<code>NoDuplicates==false</code>)
\r
2102 the check is made with respect to multiplicities, else multiplicities
\r
2103 are not taken into account.
\r
2105 <param name="items">The </param>
\r
2106 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
2108 <member name="M:C5.TreeBag`1.FindAll(C5.Filter{`0})">
\r
2110 Create a new indexed sorted collection consisting of the items of this
\r
2111 indexed sorted collection satisfying a certain predicate.
\r
2113 <param name="filter">The filter delegate defining the predicate.</param>
\r
2114 <returns>The new indexed sorted collection.</returns>
\r
2116 <member name="M:C5.TreeBag`1.Map``1(C5.Mapper{`0,``0},C5.IComparer{``0})">
\r
2118 Create a new indexed sorted collection consisting of the results of
\r
2119 mapping all items of this list.
\r
2120 <exception cref="T:System.ArgumentException"/> if the map is not increasing over
\r
2121 the items of this collection (with respect to the two given comparison
\r
2124 <param name="mapper">The delegate definging the map.</param>
\r
2125 <param name="c">The comparion relation to use for the result.</param>
\r
2126 <returns>The new sorted collection.</returns>
\r
2128 <member name="M:C5.TreeBag`1.ContainsCount(`0)">
\r
2130 Count the number of items of the collection equal to a particular value.
\r
2131 Returns 0 if and only if the value is not in the collection.
\r
2133 <param name="item">The value to count.</param>
\r
2134 <returns>The number of copies found.</returns>
\r
2136 <member name="M:C5.TreeBag`1.RemoveAllCopies(`0)">
\r
2138 Remove all items equivalent to a given value.
\r
2140 <param name="item">The value to remove.</param>
\r
2142 <member name="M:C5.TreeBag`1.IndexOf(`0)">
\r
2144 Searches for an item in the list going forwrds from the start.
\r
2146 <param name="item">Item to search for.</param>
\r
2147 <returns>Index of item from start.</returns>
\r
2149 <member name="M:C5.TreeBag`1.LastIndexOf(`0)">
\r
2151 Searches for an item in the list going backwords from the end.
\r
2153 <param name="item">Item to search for.</param>
\r
2154 <returns>Index of of item from the end.</returns>
\r
2156 <member name="M:C5.TreeBag`1.RemoveAt(System.Int32)">
\r
2158 Remove the item at a specific position of the list.
\r
2159 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
2160 >= the size of the collection.
\r
2162 <param name="i">The index of the item to remove.</param>
\r
2163 <returns>The removed item.</returns>
\r
2165 <member name="M:C5.TreeBag`1.RemoveInterval(System.Int32,System.Int32)">
\r
2167 Remove all items in an index interval.
\r
2168 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
2170 <param name="start">The index of the first item to remove.</param>
\r
2171 <param name="count">The number of items to remove.</param>
\r
2173 <member name="M:C5.TreeBag`1.Backwards">
\r
2175 Create a collection containing the same items as this collection, but
\r
2176 whose enumerator will enumerate the items backwards. The new collection
\r
2177 will become invalid if the original is modified. Method typicaly used as in
\r
2178 <code>foreach (T x in coll.Backwards()) {...}</code>
\r
2180 <returns>The backwards collection.</returns>
\r
2182 <member name="M:C5.TreeBag`1.FindMin">
\r
2184 Find the current least item of this priority queue.
\r
2186 <returns>The least item.</returns>
\r
2188 <member name="M:C5.TreeBag`1.DeleteMin">
\r
2190 Remove the least item from this priority queue.
\r
2192 <returns>The removed item.</returns>
\r
2194 <member name="M:C5.TreeBag`1.FindMax">
\r
2196 Find the current largest item of this priority queue.
\r
2198 <returns>The largest item.</returns>
\r
2200 <member name="M:C5.TreeBag`1.DeleteMax">
\r
2202 Remove the largest item from this priority queue.
\r
2204 <returns>The removed item.</returns>
\r
2206 <member name="M:C5.TreeBag`1.Predecessor(`0)">
\r
2208 Find the strict predecessor in the sorted collection of a particular value,
\r
2209 i.e. the largest item in the collection less than the supplied value.
\r
2210 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
2211 supplied value is less than or equal to the minimum of this collection.)
\r
2213 <param name="item">The item to find the predecessor for.</param>
\r
2214 <returns>The predecessor.</returns>
\r
2216 <member name="M:C5.TreeBag`1.WeakPredecessor(`0)">
\r
2218 Find the weak predecessor in the sorted collection of a particular value,
\r
2219 i.e. the largest item in the collection less than or equal to the supplied value.
\r
2220 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
2221 supplied value is less than the minimum of this collection.)
\r
2223 <param name="item">The item to find the weak predecessor for.</param>
\r
2224 <returns>The weak predecessor.</returns>
\r
2226 <member name="M:C5.TreeBag`1.Successor(`0)">
\r
2228 Find the strict successor in the sorted collection of a particular value,
\r
2229 i.e. the least item in the collection greater than the supplied value.
\r
2230 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
2231 supplied value is greater than or equal to the maximum of this collection.)
\r
2233 <param name="item">The item to find the successor for.</param>
\r
2234 <returns>The successor.</returns>
\r
2236 <member name="M:C5.TreeBag`1.WeakSuccessor(`0)">
\r
2238 Find the weak successor in the sorted collection of a particular value,
\r
2239 i.e. the least item in the collection greater than or equal to the supplied value.
\r
2240 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
2241 supplied value is greater than the maximum of this collection.)
\r
2243 <param name="item">The item to find the weak successor for.</param>
\r
2244 <returns>The weak successor.</returns>
\r
2246 <member name="M:C5.TreeBag`1.RangeFrom(`0)">
\r
2248 Query this sorted collection for items greater than or equal to a supplied value.
\r
2250 <param name="bot">The lower bound (inclusive).</param>
\r
2251 <returns>The result directed collection.</returns>
\r
2253 <member name="M:C5.TreeBag`1.RangeFromTo(`0,`0)">
\r
2255 Query this sorted collection for items between two supplied values.
\r
2257 <param name="bot">The lower bound (inclusive).</param>
\r
2258 <param name="top">The upper bound (exclusive).</param>
\r
2259 <returns>The result directed collection.</returns>
\r
2261 <member name="M:C5.TreeBag`1.RangeTo(`0)">
\r
2263 Query this sorted collection for items less than a supplied value.
\r
2265 <param name="top">The upper bound (exclusive).</param>
\r
2266 <returns>The result directed collection.</returns>
\r
2268 <member name="M:C5.TreeBag`1.RangeAll">
\r
2270 Create a directed collection with the same items as this collection.
\r
2272 <returns>The result directed collection.</returns>
\r
2274 <member name="M:C5.TreeBag`1.Cut(System.IComparable{`0},`0@,System.Boolean@,`0@,System.Boolean@)">
\r
2276 Perform a search in the sorted collection for the ranges in which a
\r
2277 non-decreasing function from the item type to <code>int</code> is
\r
2278 negative, zero respectively positive. If the supplied cut function is
\r
2279 not non-decreasing, the result of this call is undefined.
\r
2281 <param name="c">The cut function <code>T</code> to <code>int</code>, given
\r
2282 as an <code>IComparable<T></code> object, where the cut function is
\r
2283 the <code>c.CompareTo(T that)</code> method.</param>
\r
2284 <param name="low">Returns the largest item in the collection, where the
\r
2285 cut function is negative (if any).</param>
\r
2286 <param name="lowIsValid">True if the cut function is negative somewhere
\r
2287 on this collection.</param>
\r
2288 <param name="high">Returns the least item in the collection, where the
\r
2289 cut function is positive (if any).</param>
\r
2290 <param name="highIsValid">True if the cut function is positive somewhere
\r
2291 on this collection.</param>
\r
2292 <returns></returns>
\r
2294 <member name="M:C5.TreeBag`1.CountFrom(`0)">
\r
2296 Determine the number of items at or above a supplied threshold.
\r
2298 <param name="bot">The lower bound (inclusive)</param>
\r
2299 <returns>The number of matcing items.</returns>
\r
2301 <member name="M:C5.TreeBag`1.CountFromTo(`0,`0)">
\r
2303 Determine the number of items between two supplied thresholds.
\r
2305 <param name="bot">The lower bound (inclusive)</param>
\r
2306 <param name="top">The upper bound (exclusive)</param>
\r
2307 <returns>The number of matcing items.</returns>
\r
2309 <member name="M:C5.TreeBag`1.CountTo(`0)">
\r
2311 Determine the number of items below a supplied threshold.
\r
2313 <param name="top">The upper bound (exclusive)</param>
\r
2314 <returns>The number of matcing items.</returns>
\r
2316 <member name="M:C5.TreeBag`1.RemoveRangeFrom(`0)">
\r
2318 Remove all items of this collection above or at a supplied threshold.
\r
2320 <param name="low">The lower threshold (inclusive).</param>
\r
2322 <member name="M:C5.TreeBag`1.RemoveRangeFromTo(`0,`0)">
\r
2324 Remove all items of this collection between two supplied thresholds.
\r
2326 <param name="low">The lower threshold (inclusive).</param>
\r
2327 <param name="hi">The upper threshold (exclusive).</param>
\r
2329 <member name="M:C5.TreeBag`1.RemoveRangeTo(`0)">
\r
2331 Remove all items of this collection below a supplied threshold.
\r
2333 <param name="hi">The upper threshold (exclusive).</param>
\r
2335 <member name="M:C5.TreeBag`1.Dispose">
\r
2337 If this tree is a snapshot, remove registration in base tree
\r
2340 <member name="M:C5.TreeBag`1.Finalize">
\r
2342 If this tree is a snapshot, remove registration in base tree
\r
2345 <member name="M:C5.TreeBag`1.Snapshot">
\r
2347 Make a (read-only) snap shot of this collection.
\r
2349 <returns>The snap shot.</returns>
\r
2351 <member name="M:C5.TreeBag`1.minidump(C5.TreeBag{`0}.Node,System.String)">
\r
2353 Display this node on the console, and recursively its subnodes.
\r
2355 <param name="n">Node to display</param>
\r
2356 <param name="space">Indentation</param>
\r
2358 <member name="M:C5.TreeBag`1.dump">
\r
2360 Print the tree structure to the console stdout.
\r
2363 <member name="M:C5.TreeBag`1.dump(System.String)">
\r
2365 Print the tree structure to the console stdout.
\r
2368 <member name="M:C5.TreeBag`1.dump(System.String,System.String)">
\r
2370 Display this tree on the console.
\r
2372 <param name="msg">Identifying string of this call to dump</param>
\r
2373 <param name="err">Extra (error)message to include</param>
\r
2375 <member name="M:C5.TreeBag`1.massert(System.Boolean,C5.TreeBag{`0}.Node,System.String,System.IO.TextWriter)">
\r
2377 Print warning m on o if b is false.
\r
2379 <param name="b">Condition that should hold</param>
\r
2380 <param name="n">Place (used for id display)</param>
\r
2381 <param name="m">Message</param>
\r
2382 <param name="o">Output stream</param>
\r
2383 <returns>b</returns>
\r
2385 <member name="M:C5.TreeBag`1.Check(System.String)">
\r
2387 Checks red-black invariant. Dumps tree to console if bad
\r
2389 <param name="name">Title of dump</param>
\r
2390 <returns>false if invariant violation</returns>
\r
2392 <member name="M:C5.TreeBag`1.Check">
\r
2394 Checks red-black invariant. Dumps tree to console if bad
\r
2396 <returns>false if invariant violation</returns>
\r
2398 <member name="P:C5.TreeBag`1.Features">
\r
2400 A debugging aid for making the selected compilation alternatives
\r
2401 available to the user. (To be removed when selection is finally fixed
\r
2402 for production version).
\r
2405 <member name="P:C5.TreeBag`1.AllowsDuplicates">
\r
2406 <summary></summary>
\r
2407 <value>True since this collection has bag semantics.</value>
\r
2409 <member name="P:C5.TreeBag`1.ContainsSpeed">
\r
2411 The value is symbolic indicating the type of asymptotic complexity
\r
2412 in terms of the size of this collection (worst-case or amortized as
\r
2415 <value>Speed.Log</value>
\r
2417 <member name="P:C5.TreeBag`1.Item(System.Int32)">
\r
2419 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
2420 >= the size of the collection.
\r
2422 <value>The i'th item of this list.</value>
\r
2423 <param name="i">the index to lookup</param>
\r
2425 <member name="P:C5.TreeBag`1.Item(System.Int32,System.Int32)">
\r
2427 <exception cref="T:System.IndexOutOfRangeException"/>.
\r
2429 <value>The directed collection of items in a specific index interval.</value>
\r
2430 <param name="start">The low index of the interval (inclusive).</param>
\r
2431 <param name="end">The high index of the interval (exclusive).</param>
\r
2433 <member name="P:C5.TreeBag`1.Comparer">
\r
2435 The comparer object supplied at creation time for this collection
\r
2437 <value>The comparer</value>
\r
2439 <member name="T:C5.TreeBag`1.Feature">
\r
2441 A debugging aid for making the selected compilation alternatives
\r
2442 available to the user. (To be removed when selection is finally fixed
\r
2443 for production version).
\r
2446 <member name="F:C5.TreeBag`1.Feature.Dummy">
\r
2451 <member name="F:C5.TreeBag`1.Feature.NodeCopyPersistence">
\r
2453 Node copy persistence as explained in <a href="litterature.htm#Tarjan1">Tarjan1</a>
\r
2456 <member name="F:C5.TreeBag`1.Feature.Sizes">
\r
2458 Maintain sub tree sizes
\r
2461 <member name="F:C5.TreeBag`1.Feature.Heights">
\r
2463 Maintain precise node heights
\r
2466 <member name="F:C5.TreeBag`1.Feature.Ranks">
\r
2468 Maintain node ranks (~ black height)
\r
2471 <member name="F:C5.TreeBag`1.Feature.Traceid">
\r
2473 Maintain unique ids on tree nodes.
\r
2476 <member name="T:C5.TreeBag`1.Node">
\r
2478 The type of node in a Red-Black binary tree
\r
2481 <member name="M:C5.TreeBag`1.Node.update(C5.TreeBag{`0}.Node@,System.Boolean,C5.TreeBag{`0}.Node,System.Int32,System.Int32)">
\r
2483 Update a child pointer
\r
2485 <param name="cursor"></param>
\r
2486 <param name="leftnode"></param>
\r
2487 <param name="child"></param>
\r
2488 <param name="maxsnapid"></param>
\r
2489 <param name="generation"></param>
\r
2490 <returns>True if node was *copied*</returns>
\r
2492 <member name="T:C5.TreeBag`1.Enumerator">
\r
2494 An enumerator for a red-black tree collection. Based on an explicit stack
\r
2495 of subtrees waiting to be enumerated. Currently only used for the tree set
\r
2496 enumerators (tree bag enumerators use an iterator block based enumerator).
\r
2499 <member name="M:C5.TreeBag`1.Enumerator.#ctor(C5.TreeBag{`0})">
\r
2501 Create a tree enumerator
\r
2503 <param name="tree">The red-black tree to enumerate</param>
\r
2505 <member name="M:C5.TreeBag`1.Enumerator.MoveNext">
\r
2507 Move enumerator to next item in tree, or the first item if
\r
2508 this is the first call to MoveNext.
\r
2509 <exception cref="T:System.InvalidOperationException"/> if underlying tree was modified.
\r
2511 <returns>True if enumerator is valid now</returns>
\r
2513 <member name="M:C5.TreeBag`1.Enumerator.Dispose">
\r
2515 Call Dispose(true) and then suppress finalization of this enumerator.
\r
2518 <member name="M:C5.TreeBag`1.Enumerator.Dispose(System.Boolean)">
\r
2520 Remove the internal data (notably the stack array).
\r
2522 <param name="disposing">True if called from Dispose(),
\r
2523 false if called from the finalizer</param>
\r
2525 <member name="M:C5.TreeBag`1.Enumerator.Finalize">
\r
2527 Finalizer for enumeratir
\r
2530 <member name="P:C5.TreeBag`1.Enumerator.Current">
\r
2532 Undefined if enumerator is not valid (MoveNext hash been called returning true)
\r
2534 <value>The current item of the enumerator.</value>
\r
2536 <member name="T:C5.TreeBag`1.SnapEnumerator">
\r
2538 An enumerator for a snapshot of a node copy persistent red-black tree
\r
2542 <member name="M:C5.TreeBag`1.SnapEnumerator.#ctor(C5.TreeBag{`0})">
\r
2544 Creta an enumerator for a snapshot of a node copy persistent red-black tree
\r
2547 <param name="tree">The snapshot</param>
\r
2549 <member name="M:C5.TreeBag`1.SnapEnumerator.MoveNext">
\r
2551 Move enumerator to next item in tree, or the first item if
\r
2552 this is the first call to MoveNext.
\r
2553 <exception cref="T:System.InvalidOperationException"/> if underlying tree was modified.
\r
2555 <returns>True if enumerator is valid now</returns>
\r
2557 <member name="P:C5.TreeBag`1.SnapEnumerator.Current">
\r
2559 Undefined if enumerator is not valid (MoveNext hash been called returning true)
\r
2561 <value>The current value of the enumerator.</value>
\r
2563 <member name="M:C5.TreeBag`1.Range.Enumerator.MoveNext">
\r
2565 Move enumerator to next item in tree, or the first item if
\r
2566 this is the first call to MoveNext.
\r
2567 <exception cref="T:System.InvalidOperationException"/> if underlying tree was modified.
\r
2569 <returns>True if enumerator is valid now</returns>
\r
2571 <member name="P:C5.TreeBag`1.Range.Enumerator.Current">
\r
2573 Undefined if enumerator is not valid (MoveNext hash been called returning true)
\r
2575 <value>The current value of the enumerator.</value>
\r
2577 <member name="T:C5.TreeDictionary`2">
\r
2579 A sorted generic dictionary based on a red-black tree set.
\r
2582 <member name="T:C5.DictionaryBase`2">
\r
2584 A base class for implementing a dictionary based on a set collection implementation.
\r
2585 <p>See the source code for <see cref="T:C5.HashDictionary!2"/> for an example</p>
\r
2589 <member name="F:C5.DictionaryBase`2.pairs">
\r
2591 The set collection of entries underlying this dictionary implementation
\r
2594 <member name="M:C5.DictionaryBase`2.Add(`0,`1)">
\r
2596 Add a new (key, value) pair (a mapping) to the dictionary.
\r
2597 <exception cref="T:System.InvalidOperationException"/> if there already is an entry with the same key.
\r
2599 <param name="key">Key to add</param>
\r
2600 <param name="val">Value to add</param>
\r
2602 <member name="M:C5.DictionaryBase`2.Remove(`0)">
\r
2604 Remove an entry with a given key from the dictionary
\r
2606 <param name="key">The key of the entry to remove</param>
\r
2607 <returns>True if an entry was found (and removed)</returns>
\r
2609 <member name="M:C5.DictionaryBase`2.Remove(`0,`1@)">
\r
2611 Remove an entry with a given key from the dictionary and report its value.
\r
2613 <param name="key">The key of the entry to remove</param>
\r
2614 <param name="val">On exit, the value of the removed entry</param>
\r
2615 <returns>True if an entry was found (and removed)</returns>
\r
2617 <member name="M:C5.DictionaryBase`2.Clear">
\r
2619 Remove all entries from the dictionary
\r
2622 <member name="M:C5.DictionaryBase`2.Contains(`0)">
\r
2624 Check if there is an entry with a specified key
\r
2626 <param name="key">The key to look for</param>
\r
2627 <returns>True if key was found</returns>
\r
2629 <member name="M:C5.DictionaryBase`2.Find(`0,`1@)">
\r
2631 Check if there is an entry with a specified key and report the corresponding
\r
2632 value if found. This can be seen as a safe form of "val = this[key]".
\r
2634 <param name="key">The key to look for</param>
\r
2635 <param name="val">On exit, the value of the entry</param>
\r
2636 <returns>True if key was found</returns>
\r
2638 <member name="M:C5.DictionaryBase`2.Update(`0,`1)">
\r
2640 Look for a specific key in the dictionary and if found replace the value with a new one.
\r
2641 This can be seen as a non-adding version of "this[key] = val".
\r
2643 <param name="key">The key to look for</param>
\r
2644 <param name="val">The new value</param>
\r
2645 <returns>True if key was found</returns>
\r
2647 <member name="M:C5.DictionaryBase`2.FindOrAdd(`0,`1@)">
\r
2649 Look for a specific key in the dictionary. If found, report the corresponding value,
\r
2650 else add an entry with the key and the supplied value.
\r
2652 <param name="key">The key to look for</param>
\r
2653 <param name="val">On entry the value to add if the key is not found.
\r
2654 On exit the value found if any.</param>
\r
2655 <returns>True if key was found</returns>
\r
2657 <member name="M:C5.DictionaryBase`2.UpdateOrAdd(`0,`1)">
\r
2659 Update value in dictionary corresponding to key if found, else add new entry.
\r
2660 More general than "this[key] = val;" by reporting if key was found.
\r
2662 <param name="key">The key to look for</param>
\r
2663 <param name="val">The value to add or replace with.</param>
\r
2664 <returns>True if entry was updated.</returns>
\r
2666 <member name="M:C5.DictionaryBase`2.Check">
\r
2668 Check the integrity of the internal data structures of this dictionary.
\r
2669 Only avaliable in DEBUG builds???
\r
2671 <returns>True if check does not fail.</returns>
\r
2673 <member name="M:C5.DictionaryBase`2.GetEnumerator">
\r
2675 Create an enumerator for the collection of entries of the dictionary
\r
2677 <returns>The enumerator</returns>
\r
2679 <member name="P:C5.DictionaryBase`2.Count">
\r
2683 <value>The number of entrues in the dictionary</value>
\r
2685 <member name="P:C5.DictionaryBase`2.SyncRoot">
\r
2689 <value>A distinguished object to use for locking to synchronize multithreaded access</value>
\r
2691 <member name="P:C5.DictionaryBase`2.Keys">
\r
2695 <value>A collection containg the all the keys of the dictionary</value>
\r
2697 <member name="P:C5.DictionaryBase`2.Values">
\r
2701 <value>A collection containing all the values of the dictionary</value>
\r
2703 <member name="P:C5.DictionaryBase`2.Item(`0)">
\r
2705 Indexer for dictionary.
\r
2706 <exception cref="T:System.InvalidOperationException"/> if no entry is found.
\r
2708 <value>The value corresponding to the key</value>
\r
2710 <member name="P:C5.DictionaryBase`2.IsReadOnly">
\r
2714 <value>True if dictionary is read only</value>
\r
2716 <member name="M:C5.TreeDictionary`2.#ctor">
\r
2718 Create a red-black tree dictionary using the natural comparer for keys.
\r
2719 <exception cref="T:System.ArgumentException"/> if the key type K is not comparable.
\r
2722 <member name="M:C5.TreeDictionary`2.#ctor(C5.IComparer{`0})">
\r
2724 Create a red-black tree dictionary using an external comparer for keys.
\r
2726 <param name="c">The external comparer</param>
\r
2728 <member name="M:C5.TreeDictionary`2.Predecessor(`0)">
\r
2730 Get the entry in the dictionary whose key is the
\r
2731 predecessor of a specified key.
\r
2733 <param name="key">The key</param>
\r
2734 <returns>The entry</returns>
\r
2736 <member name="M:C5.TreeDictionary`2.WeakPredecessor(`0)">
\r
2738 Get the entry in the dictionary whose key is the
\r
2739 weak predecessor of a specified key.
\r
2741 <param name="key">The key</param>
\r
2742 <returns>The entry</returns>
\r
2744 <member name="M:C5.TreeDictionary`2.Successor(`0)">
\r
2746 Get the entry in the dictionary whose key is the
\r
2747 successor of a specified key.
\r
2749 <param name="key">The key</param>
\r
2750 <returns>The entry</returns>
\r
2752 <member name="M:C5.TreeDictionary`2.WeakSuccessor(`0)">
\r
2754 Get the entry in the dictionary whose key is the
\r
2755 weak successor of a specified key.
\r
2757 <param name="key">The key</param>
\r
2758 <returns>The entry</returns>
\r
2760 <member name="M:C5.TreeDictionary`2.Snapshot">
\r
2762 Make a snapshot of the current state of this dictionary
\r
2764 <returns>The snapshot</returns>
\r
2766 <member name="T:C5.HashedLinkedList`1">
\r
2768 A list collection based on a doubly linked list data structure with
\r
2769 a hash index mapping item to node.
\r
2772 <member name="T:C5.LinkedList`1">
\r
2774 A list collection class based on a doubly linked list data structure.
\r
2777 <member name="F:C5.LinkedList`1.fIFO">
\r
2779 IExtensible.Add(T) always does AddLast(T), fIFO determines
\r
2780 if T Remove() does RemoveFirst() or RemoveLast()
\r
2783 <member name="F:C5.LinkedList`1.maintaintags">
\r
2785 True if we maintain tags for node ordering (false for plain linked list, true for hashed linked list).
\r
2788 <member name="F:C5.LinkedList`1.startsentinel">
\r
2790 Node to the left of first node
\r
2793 <member name="F:C5.LinkedList`1.endsentinel">
\r
2795 Node to the right of last node
\r
2798 <member name="F:C5.LinkedList`1.offset">
\r
2800 Offset of this view in underlying list
\r
2803 <member name="F:C5.LinkedList`1.underlying">
\r
2805 underlying list of theis view (or null)
\r
2808 <member name="M:C5.LinkedList`1.updatecheck">
\r
2810 Check if it is valid to perform updates and increment stamp.
\r
2811 <exception cref="T:System.InvalidOperationException"/> if check fails.
\r
2812 <br/>This method should be called at the start of any public modifying methods.
\r
2815 <member name="M:C5.LinkedList`1.modifycheck">
\r
2817 Check if we are a view that the underlyinglist has only been updated through us.
\r
2818 <exception cref="T:System.InvalidOperationException"/> if check fails.
\r
2820 This method should be called from enumerators etc to guard against
\r
2821 modification of the base collection.
\r
2824 <member name="M:C5.LinkedList`1.modifycheck(System.Int32)">
\r
2826 Check that the list has not been updated since a particular time.
\r
2827 <exception cref="T:System.InvalidOperationException"/> if check fails.
\r
2829 <param name="stamp">The stamp indicating the time.</param>
\r
2831 <member name="M:C5.LinkedList`1.insertNode(C5.LinkedList{`0}.Node,C5.LinkedList{`0}.Node)">
\r
2833 Insert a Node before another one. Unchecked internal version.
\r
2835 <param name="succ">The successor to be</param>
\r
2836 <param name="newnode">Node to insert</param>
\r
2838 <member name="M:C5.LinkedList`1.remove(C5.LinkedList{`0}.Node)">
\r
2840 Remove a node. Unchecked internal version.
\r
2842 <param name="node">Node to remove</param>
\r
2843 <returns>The item of the removed node</returns>
\r
2845 <member name="M:C5.LinkedList`1.gettaggroup(C5.LinkedList{`0}.Node,C5.LinkedList{`0}.Node,System.Int32@,System.Int32@)">
\r
2849 <param name="pred"></param>
\r
2850 <param name="succ"></param>
\r
2851 <param name="lowbound"></param>
\r
2852 <param name="highbound"></param>
\r
2853 <returns></returns>
\r
2855 <member name="M:C5.LinkedList`1.settag(C5.LinkedList{`0}.Node)">
\r
2857 Put a tag on a node (already inserted in the list). Split taggroups and renumber as
\r
2860 <param name="node">The node to tag</param>
\r
2862 <member name="M:C5.LinkedList`1.removefromtaggroup(C5.LinkedList{`0}.Node)">
\r
2864 Remove a node from its taggroup.
\r
2865 <br/> When this is called, node must already have been removed from the underlying list
\r
2867 <param name="node">The node to remove</param>
\r
2869 <member name="M:C5.LinkedList`1.splittaggroup(C5.LinkedList{`0}.TagGroup)">
\r
2871 Split a tag group to make rom for more tags.
\r
2873 <param name="taggroup">The tag group</param>
\r
2875 <member name="M:C5.LinkedList`1.#ctor(C5.IHasher{`0})">
\r
2877 Create a linked list with en external item hasher
\r
2879 <param name="itemhasher">The external hasher</param>
\r
2881 <member name="M:C5.LinkedList`1.#ctor">
\r
2883 Create a linked list with the nmatural item hasher
\r
2886 <member name="M:C5.LinkedList`1.get(System.Int32)">
\r
2888 Return the node at position n
\r
2890 <param name="n"></param>
\r
2891 <returns></returns>
\r
2893 <member name="M:C5.LinkedList`1.Insert(System.Int32,`0)">
\r
2895 Insert an item at a specific index location in this list.
\r
2896 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
2897 > the size of the collection.</summary>
\r
2898 <param name="i">The index at which to insert.</param>
\r
2899 <param name="item">The item to insert.</param>
\r
2901 <member name="M:C5.LinkedList`1.InsertAll(System.Int32,System.Collections.Generic.IEnumerable{`0})">
\r
2903 Insert into this list all items from an enumerable collection starting
\r
2904 at a particular index.
\r
2905 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
2906 > the size of the collection.
\r
2908 <param name="i">Index to start inserting at</param>
\r
2909 <param name="items">Items to insert</param>
\r
2911 <member name="M:C5.LinkedList`1.InsertBefore(`0,`0)">
\r
2913 Insert an item right before the first occurrence of some target item.
\r
2914 <exception cref="T:System.ArgumentException"/> if target is not found
\r
2916 <param name="item">The item to insert.</param>
\r
2917 <param name="target">The target before which to insert.</param>
\r
2919 <member name="M:C5.LinkedList`1.InsertAfter(`0,`0)">
\r
2921 Insert an item right after the last(???) occurrence of some target item.
\r
2922 <exception cref="T:System.ArgumentException"/> if target is not found
\r
2924 <param name="item">The item to insert.</param>
\r
2925 <param name="target">The target after which to insert.</param>
\r
2927 <member name="M:C5.LinkedList`1.InsertFirst(`0)">
\r
2929 Insert an item at the front of this list.
\r
2931 <param name="item">The item to insert.</param>
\r
2933 <member name="M:C5.LinkedList`1.InsertLast(`0)">
\r
2935 Insert an item at the back of this list.
\r
2937 <param name="item">The item to insert.</param>
\r
2939 <member name="M:C5.LinkedList`1.Map``1(C5.Mapper{`0,``0})">
\r
2941 Create a new list consisting of the results of mapping all items of this
\r
2944 <param name="mapper">The delegate definging the map.</param>
\r
2945 <returns>The new list.</returns>
\r
2947 <member name="M:C5.LinkedList`1.Map``1(C5.Mapper{`0,``0},C5.IHasher{``0})">
\r
2949 Create a new list consisting of the results of mapping all items of this
\r
2950 list. The new list will use a specified hasher for the item type.
\r
2952 <typeparam name="V">The type of items of the new list</typeparam>
\r
2953 <param name="mapper">The delegate defining the map.</param>
\r
2954 <param name="hasher">The hasher to use for the new list</param>
\r
2955 <returns>The new list.</returns>
\r
2957 <member name="M:C5.LinkedList`1.Remove">
\r
2959 Remove one item from the list: from the front if <code>FIFO</code>
\r
2960 is true, else from the back.
\r
2961 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
2963 <returns>The removed item.</returns>
\r
2965 <member name="M:C5.LinkedList`1.RemoveFirst">
\r
2967 Remove one item from the front of the list.
\r
2968 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
2970 <returns>The removed item.</returns>
\r
2972 <member name="M:C5.LinkedList`1.RemoveLast">
\r
2974 Remove one item from the back of the list.
\r
2975 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
2977 <returns>The removed item.</returns>
\r
2979 <member name="M:C5.LinkedList`1.View(System.Int32,System.Int32)">
\r
2981 Create a list view on this list.
\r
2982 <exception cref="T:System.ArgumentOutOfRangeException"/> if the start or count is negative
\r
2983 <exception cref="T:System.ArgumentException"/> if the range does not fit within list.
\r
2985 <param name="start">The index in this list of the start of the view.</param>
\r
2986 <param name="count">The size of the view.</param>
\r
2987 <returns>The new list view.</returns>
\r
2989 <member name="M:C5.LinkedList`1.Slide(System.Int32)">
\r
2991 Slide this list view along the underlying list.
\r
2992 <exception cref="T:System.InvalidOperationException"/> if this list is not a view.
\r
2993 <exception cref="T:System.ArgumentOutOfRangeException"/> if the operation
\r
2994 would bring either end of the view outside the underlying list.
\r
2996 <param name="offset">The signed amount to slide: positive to slide
\r
2997 towards the end.</param>
\r
2999 <member name="M:C5.LinkedList`1.Slide(System.Int32,System.Int32)">
\r
3001 Slide this list view along the underlying list, changing its size.
\r
3002 <exception cref="T:System.InvalidOperationException"/> if this list is not a view.
\r
3003 <exception cref="T:System.ArgumentOutOfRangeException"/> if the operation
\r
3004 would bring either end of the view outside the underlying list.
\r
3006 <param name="offset">The signed amount to slide: positive to slide
\r
3007 towards the end.</param>
\r
3008 <param name="size">The new size of the view.</param>
\r
3010 <member name="M:C5.LinkedList`1.Reverse">
\r
3012 Reverse the list so the items are in the opposite sequence order.
\r
3015 <member name="M:C5.LinkedList`1.Reverse(System.Int32,System.Int32)">
\r
3017 Reverst part of the list so the items are in the opposite sequence order.
\r
3018 <exception cref="T:System.ArgumentException"/> if the count is negative.
\r
3019 <exception cref="T:System.ArgumentOutOfRangeException"/> if the part does not fit
\r
3022 <param name="start">The index of the start of the part to reverse.</param>
\r
3023 <param name="count">The size of the part to reverse.</param>
\r
3025 <member name="M:C5.LinkedList`1.IsSorted(C5.IComparer{`0})">
\r
3027 Check if this list is sorted according to a specific sorting order.
\r
3029 <param name="c">The comparer defining the sorting order.</param>
\r
3030 <returns>True if the list is sorted, else false.</returns>
\r
3032 <member name="M:C5.LinkedList`1.Sort(C5.IComparer{`0})">
\r
3034 Sort the items of the list according to a specific sorting order.
\r
3035 The sorting is stable.
\r
3037 <param name="c">The comparer defining the sorting order.</param>
\r
3039 <member name="M:C5.LinkedList`1.Shuffle">
\r
3041 Randonmly shuffle the items of this list.
\r
3044 <member name="M:C5.LinkedList`1.Shuffle(System.Random)">
\r
3046 Shuffle the items of this list according to a specific random source.
\r
3048 <param name="rnd">The random source.</param>
\r
3050 <member name="M:C5.LinkedList`1.IndexOf(`0)">
\r
3052 Searches for an item in the list going forwrds from the start.
\r
3054 <param name="item">Item to search for.</param>
\r
3055 <returns>Index of item from start.</returns>
\r
3057 <member name="M:C5.LinkedList`1.LastIndexOf(`0)">
\r
3059 Searches for an item in the list going backwords from the end.
\r
3061 <param name="item">Item to search for.</param>
\r
3062 <returns>Index of of item from the end.</returns>
\r
3064 <member name="M:C5.LinkedList`1.RemoveAt(System.Int32)">
\r
3066 Remove the item at a specific position of the list.
\r
3067 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
3068 >= the size of the collection.
\r
3070 <param name="i">The index of the item to remove.</param>
\r
3071 <returns>The removed item.</returns>
\r
3073 <member name="M:C5.LinkedList`1.RemoveInterval(System.Int32,System.Int32)">
\r
3075 Remove all items in an index interval.
\r
3076 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
3078 <param name="start">The index of the first item to remove.</param>
\r
3079 <param name="count">The number of items to remove.</param>
\r
3081 <member name="M:C5.LinkedList`1.Backwards">
\r
3083 Create a collection containing the same items as this collection, but
\r
3084 whose enumerator will enumerate the items backwards. The new collection
\r
3085 will become invalid if the original is modified. Method typicaly used as in
\r
3086 <code>foreach (T x in coll.Backwards()) {...}</code>
\r
3088 <returns>The backwards collection.</returns>
\r
3090 <member name="M:C5.LinkedList`1.Contains(`0)">
\r
3092 Check if this collection contains (an item equivalent to according to the
\r
3093 itemhasher) a particular value.
\r
3095 <param name="item">The value to check for.</param>
\r
3096 <returns>True if the items is in this collection.</returns>
\r
3098 <member name="M:C5.LinkedList`1.Find(`0@)">
\r
3100 Check if this collection contains an item equivalent according to the
\r
3101 itemhasher to a particular value. If so, return in the ref argument (a
\r
3102 binary copy of) the actual value found.
\r
3104 <param name="item">The value to look for.</param>
\r
3105 <returns>True if the items is in this collection.</returns>
\r
3107 <member name="M:C5.LinkedList`1.Update(`0)">
\r
3109 Check if this collection contains an item equivalent according to the
\r
3110 itemhasher to a particular value. If so, update the item in the collection
\r
3111 to with a binary copy of the supplied value. Will update a single item.
\r
3113 <param name="item">Value to update.</param>
\r
3114 <returns>True if the item was found and hence updated.</returns>
\r
3116 <member name="M:C5.LinkedList`1.FindOrAdd(`0@)">
\r
3118 Check if this collection contains an item equivalent according to the
\r
3119 itemhasher to a particular value. If so, return in the ref argument (a
\r
3120 binary copy of) the actual value found. Else, add the item to the collection.
\r
3122 <param name="item">The value to look for.</param>
\r
3123 <returns>True if the item was found (hence not added).</returns>
\r
3125 <member name="M:C5.LinkedList`1.UpdateOrAdd(`0)">
\r
3127 Check if this collection contains an item equivalent according to the
\r
3128 itemhasher to a particular value. If so, update the item in the collection
\r
3129 to with a binary copy of the supplied value; else add the value to the collection.
\r
3131 <param name="item">Value to add or update.</param>
\r
3132 <returns>True if the item was updated (hence not added).</returns>
\r
3134 <member name="M:C5.LinkedList`1.Remove(`0)">
\r
3136 Remove a particular item from this collection. Since the collection has bag
\r
3137 semantics only one copy equivalent to the supplied item is removed.
\r
3139 <param name="item">The value to remove.</param>
\r
3140 <returns>True if the item was found (and removed).</returns>
\r
3142 <member name="M:C5.LinkedList`1.RemoveWithReturn(`0@)">
\r
3144 Remove a particular item from this collection if found (only one copy).
\r
3145 If an item was removed, report a binary copy of the actual item removed in
\r
3148 <param name="item">The value to remove on input.</param>
\r
3149 <returns>True if the item was found (and removed).</returns>
\r
3151 <member name="M:C5.LinkedList`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
3153 Remove all items in another collection from this one, take multiplicities into account.
\r
3155 <param name="items">The items to remove.</param>
\r
3157 <member name="M:C5.LinkedList`1.Clear">
\r
3159 Remove all items from this collection.
\r
3162 <member name="M:C5.LinkedList`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
3164 Remove all items not in some other collection from this one, take multiplicities into account.
\r
3166 <param name="items">The items to retain.</param>
\r
3168 <member name="M:C5.LinkedList`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
3170 Check if this collection contains all the values in another collection
\r
3171 with respect to multiplicities.
\r
3173 <param name="items">The </param>
\r
3174 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
3176 <member name="M:C5.LinkedList`1.FindAll(C5.Filter{`0})">
\r
3178 Create a new list consisting of the items of this list satisfying a
\r
3179 certain predicate.
\r
3181 <param name="filter">The filter delegate defining the predicate.</param>
\r
3182 <returns>The new list.</returns>
\r
3184 <member name="M:C5.LinkedList`1.ContainsCount(`0)">
\r
3186 Count the number of items of the collection equal to a particular value.
\r
3187 Returns 0 if and only if the value is not in the collection.
\r
3189 <param name="item">The value to count.</param>
\r
3190 <returns>The number of copies found.</returns>
\r
3192 <member name="M:C5.LinkedList`1.RemoveAllCopies(`0)">
\r
3194 Remove all items equivalent to a given value.
\r
3196 <param name="item">The value to remove.</param>
\r
3198 <member name="M:C5.LinkedList`1.GetEnumerator">
\r
3200 Create an enumerator for the collection
\r
3202 <returns>The enumerator</returns>
\r
3204 <member name="M:C5.LinkedList`1.Add(`0)">
\r
3206 Add an item to this collection if possible.
\r
3208 <param name="item">The item to add.</param>
\r
3209 <returns>True.</returns>
\r
3211 <member name="M:C5.LinkedList`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
3213 Add the elements from another collection to this collection.
\r
3215 <param name="items">The items to add.</param>
\r
3217 <member name="M:C5.LinkedList`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
3219 Add the elements from another collection with a more specialized item type
\r
3220 to this collection.
\r
3222 <typeparam name="U">The type of items to add</typeparam>
\r
3223 <param name="items">The items to add</param>
\r
3225 <member name="M:C5.LinkedList`1.Push(`0)">
\r
3227 Push an item to the top of the stack.
\r
3229 <param name="item">The item</param>
\r
3231 <member name="M:C5.LinkedList`1.Pop">
\r
3233 Pop the item at the top of the stack from the stack.
\r
3235 <returns>The popped item.</returns>
\r
3237 <member name="M:C5.LinkedList`1.EnQueue(`0)">
\r
3239 Enqueue an item at the back of the queue.
\r
3241 <param name="item">The item</param>
\r
3243 <member name="M:C5.LinkedList`1.DeQueue">
\r
3245 Dequeue an item from the front of the queue.
\r
3247 <returns>The item</returns>
\r
3249 <member name="M:C5.LinkedList`1.Check">
\r
3251 Check the sanity of this list
\r
3253 <returns>true if sane</returns>
\r
3255 <member name="P:C5.LinkedList`1.First">
\r
3257 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
3259 <value>The first item in this list.</value>
\r
3261 <member name="P:C5.LinkedList`1.Last">
\r
3263 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
3265 <value>The last item in this list.</value>
\r
3267 <member name="P:C5.LinkedList`1.FIFO">
\r
3269 Since <code>Add(T item)</code> always add at the end of the list,
\r
3270 this describes if list has FIFO or LIFO semantics.
\r
3272 <value>True if the <code>Remove()</code> operation removes from the
\r
3273 start of the list, false if it removes from the end.</value>
\r
3275 <member name="P:C5.LinkedList`1.Item(System.Int32)">
\r
3277 On this list, this indexer is read/write.
\r
3278 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
3279 >= the size of the collection.
\r
3281 <value>The i'th item of this list.</value>
\r
3282 <param name="index">The index of the item to fetch or store.</param>
\r
3284 <member name="P:C5.LinkedList`1.Underlying">
\r
3286 Null if this list is not a view.
\r
3288 <value>Underlying list for view.</value>
\r
3290 <member name="P:C5.LinkedList`1.Offset">
\r
3293 <value>Offset for this list view or 0 for a underlying list.</value>
\r
3295 <member name="P:C5.LinkedList`1.Item(System.Int32,System.Int32)">
\r
3297 <exception cref="T:System.IndexOutOfRangeException"/>.
\r
3299 <value>The directed collection of items in a specific index interval.</value>
\r
3300 <param name="start">The low index of the interval (inclusive).</param>
\r
3301 <param name="count">The size of the range.</param>
\r
3303 <member name="P:C5.LinkedList`1.ContainsSpeed">
\r
3305 The value is symbolic indicating the type of asymptotic complexity
\r
3306 in terms of the size of this collection (worst-case or amortized as
\r
3309 <value>Speed.Linear</value>
\r
3311 <member name="P:C5.LinkedList`1.Count">
\r
3315 <value>The number of items in this collection</value>
\r
3317 <member name="P:C5.LinkedList`1.AllowsDuplicates">
\r
3321 <value>True since this collection has bag semantics.</value>
\r
3323 <member name="T:C5.LinkedList`1.Node">
\r
3325 An individual cell in the linked list
\r
3328 <member name="F:C5.LinkedList`1.Node.prev">
\r
3330 Previous-node reference
\r
3333 <member name="F:C5.LinkedList`1.Node.next">
\r
3335 Next-node reference
\r
3338 <member name="F:C5.LinkedList`1.Node.item">
\r
3343 <member name="M:C5.LinkedList`1.Node.#ctor(`0)">
\r
3347 <param name="item">Item to insert</param>
\r
3349 <member name="M:C5.LinkedList`1.Node.#ctor(`0,C5.LinkedList{`0}.Node,C5.LinkedList{`0}.Node)">
\r
3351 Create node, specifying predecessor and successor
\r
3353 <param name="item"></param>
\r
3354 <param name="prev"></param>
\r
3355 <param name="next"></param>
\r
3357 <member name="M:C5.LinkedList`1.Node.ToString">
\r
3361 <returns>Formatted node</returns>
\r
3363 <member name="T:C5.LinkedList`1.TagGroup">
\r
3365 A group of nodes with the same high tag. Purpose is to be
\r
3366 able to tell the sequence order of two nodes without having to scan through
\r
3370 <member name="M:C5.LinkedList`1.TagGroup.ToString">
\r
3372 Pretty print a tag group
\r
3374 <returns>Formatted tag group</returns>
\r
3376 <member name="M:C5.HashedLinkedList`1.#ctor(C5.IHasher{`0})">
\r
3378 Create a hashed linked list with an external item hasher.
\r
3380 <param name="itemhasher">The external hasher</param>
\r
3382 <member name="M:C5.HashedLinkedList`1.#ctor">
\r
3384 Create a hashed linked list with the natural item hasher.
\r
3387 <member name="M:C5.HashedLinkedList`1.Insert(System.Int32,`0)">
\r
3389 Insert an item at a specific index location in this list.
\r
3390 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
3391 > the size of the collection.</summary>
\r
3392 <exception cref="T:System.InvalidOperationException"/> if the item is
\r
3393 already in the list.
\r
3394 <param name="i">The index at which to insert.</param>
\r
3395 <param name="item">The item to insert.</param>
\r
3397 <member name="M:C5.HashedLinkedList`1.InsertAll(System.Int32,System.Collections.Generic.IEnumerable{`0})">
\r
3399 Insert into this list all items from an enumerable collection starting
\r
3400 at a particular index.
\r
3401 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
3402 > the size of the collection.
\r
3403 <exception cref="T:System.InvalidOperationException"/> if one of the items to insert is
\r
3404 already in the list.
\r
3406 <param name="i">Index to start inserting at</param>
\r
3407 <param name="items">Items to insert</param>
\r
3409 <member name="M:C5.HashedLinkedList`1.InsertBefore(`0,`0)">
\r
3411 Insert an item right before the first occurrence of some target item.
\r
3412 <exception cref="T:System.ArgumentException"/> if target is not found
\r
3413 <exception cref="T:System.InvalidOperationException"/> if the item is
\r
3414 already in the list.
\r
3416 <param name="item">The item to insert.</param>
\r
3417 <param name="target">The target before which to insert.</param>
\r
3419 <member name="M:C5.HashedLinkedList`1.InsertAfter(`0,`0)">
\r
3421 Insert an item right after the last(???) occurrence of some target item.
\r
3422 <exception cref="T:System.ArgumentException"/> if target is not found
\r
3423 <exception cref="T:System.InvalidOperationException"/> if the item is
\r
3424 already in the list.
\r
3426 <param name="item">The item to insert.</param>
\r
3427 <param name="target">The target after which to insert.</param>
\r
3429 <member name="M:C5.HashedLinkedList`1.InsertFirst(`0)">
\r
3431 Insert an item at the front of this list.
\r
3432 <exception cref="T:System.InvalidOperationException"/> if the item is
\r
3433 already in the list.
\r
3435 <param name="item">The item to insert.</param>
\r
3437 <member name="M:C5.HashedLinkedList`1.InsertLast(`0)">
\r
3439 Insert an item at the back of this list.
\r
3440 <exception cref="T:System.InvalidOperationException"/> if the item is
\r
3441 already in the list.
\r
3443 <param name="item">The item to insert.</param>
\r
3445 <member name="M:C5.HashedLinkedList`1.Remove">
\r
3447 Remove one item from the list: from the front if <code>FIFO</code>
\r
3448 is true, else from the back.
\r
3449 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
3451 <returns>The removed item.</returns>
\r
3453 <member name="M:C5.HashedLinkedList`1.RemoveFirst">
\r
3455 Remove one item from the front of the list.
\r
3456 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
3458 <returns>The removed item.</returns>
\r
3460 <member name="M:C5.HashedLinkedList`1.RemoveLast">
\r
3462 Remove one item from the back of the list.
\r
3463 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
3465 <returns>The removed item.</returns>
\r
3467 <member name="M:C5.HashedLinkedList`1.View(System.Int32,System.Int32)">
\r
3469 Create a list view on this list.
\r
3470 <exception cref="T:System.ArgumentOutOfRangeException"/> if the view would not fit into
\r
3473 <param name="start">The index in this list of the start of the view.</param>
\r
3474 <param name="count">The size of the view.</param>
\r
3475 <returns>The new list view.</returns>
\r
3477 <member name="M:C5.HashedLinkedList`1.Reverse(System.Int32,System.Int32)">
\r
3479 Reverst part of the list so the items are in the opposite sequence order.
\r
3480 <exception cref="T:System.ArgumentException"/> if the count is negative.
\r
3481 <exception cref="T:System.ArgumentOutOfRangeException"/> if the part does not fit
\r
3484 <param name="start">The index of the start of the part to reverse.</param>
\r
3485 <param name="count">The size of the part to reverse.</param>
\r
3487 <member name="M:C5.HashedLinkedList`1.Shuffle(System.Random)">
\r
3489 Shuffle the items of this list according to a specific random source.
\r
3491 <param name="rnd">The random source.</param>
\r
3493 <member name="M:C5.HashedLinkedList`1.IndexOf(`0)">
\r
3495 Searches for an item in the list going forwrds from the start.
\r
3497 <param name="item">Item to search for.</param>
\r
3498 <returns>Index of item from start.</returns>
\r
3500 <member name="M:C5.HashedLinkedList`1.LastIndexOf(`0)">
\r
3502 Searches for an item in the list going backwords from the end.
\r
3504 <param name="item">Item to search for.</param>
\r
3505 <returns>Index of of item from the end.</returns>
\r
3507 <member name="M:C5.HashedLinkedList`1.RemoveAt(System.Int32)">
\r
3509 Remove the item at a specific position of the list.
\r
3510 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
3511 >= the size of the collection.
\r
3513 <param name="i">The index of the item to remove.</param>
\r
3514 <returns>The removed item.</returns>
\r
3516 <member name="M:C5.HashedLinkedList`1.RemoveInterval(System.Int32,System.Int32)">
\r
3518 Remove all items in an index interval.
\r
3519 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
3521 <param name="start">The index of the first item to remove.</param>
\r
3522 <param name="count">The number of items to remove.</param>
\r
3524 <member name="M:C5.HashedLinkedList`1.Contains(`0)">
\r
3526 Check if this collection contains (an item equivalent to according to the
\r
3527 itemhasher) a particular value.
\r
3529 <param name="item">The value to check for.</param>
\r
3530 <returns>True if the items is in this collection.</returns>
\r
3532 <member name="M:C5.HashedLinkedList`1.Find(`0@)">
\r
3534 Check if this collection contains an item equivalent according to the
\r
3535 itemhasher to a particular value. If so, return in the ref argument (a
\r
3536 binary copy of) the actual value found.
\r
3538 <param name="item">The value to look for.</param>
\r
3539 <returns>True if the items is in this collection.</returns>
\r
3541 <member name="M:C5.HashedLinkedList`1.Update(`0)">
\r
3543 Check if this collection contains an item equivalent according to the
\r
3544 itemhasher to a particular value. If so, update the item in the collection
\r
3545 to with a binary copy of the supplied value.
\r
3547 <param name="item">Value to update.</param>
\r
3548 <returns>True if the item was found and hence updated.</returns>
\r
3550 <member name="M:C5.HashedLinkedList`1.FindOrAdd(`0@)">
\r
3552 Check if this collection contains an item equivalent according to the
\r
3553 itemhasher to a particular value. If so, return in the ref argument (a
\r
3554 binary copy of) the actual value found. Else, add the item to the collection.
\r
3556 <param name="item">The value to look for.</param>
\r
3557 <returns>True if the item was found (hence not added).</returns>
\r
3559 <member name="M:C5.HashedLinkedList`1.UpdateOrAdd(`0)">
\r
3561 Check if this collection contains an item equivalent according to the
\r
3562 itemhasher to a particular value. If so, update the item in the collection
\r
3563 to with a binary copy of the supplied value; else add the value to the collection.
\r
3565 <param name="item">Value to add or update.</param>
\r
3566 <returns>True if the item was found and updated (hence not added).</returns>
\r
3568 <member name="M:C5.HashedLinkedList`1.Remove(`0)">
\r
3570 Remove a particular item from this collection.
\r
3572 <param name="item">The value to remove.</param>
\r
3573 <returns>True if the item was found (and removed).</returns>
\r
3575 <member name="M:C5.HashedLinkedList`1.RemoveWithReturn(`0@)">
\r
3577 Remove a particular item from this collection if found.
\r
3578 If an item was removed, report a binary copy of the actual item removed in
\r
3581 <param name="item">The value to remove on input.</param>
\r
3582 <returns>True if the item was found (and removed).</returns>
\r
3584 <member name="M:C5.HashedLinkedList`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
3586 Remove all items in another collection from this one.
\r
3588 <param name="items">The items to remove.</param>
\r
3590 <member name="M:C5.HashedLinkedList`1.Clear">
\r
3592 Remove all items from this collection.
\r
3595 <member name="M:C5.HashedLinkedList`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
3597 Remove all items not in some other collection from this one.
\r
3599 <param name="items">The items to retain.</param>
\r
3601 <member name="M:C5.HashedLinkedList`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
3603 Check if this collection contains all the values in another collection
\r
3605 are not taken into account.
\r
3607 <param name="items">The </param>
\r
3608 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
3610 <member name="M:C5.HashedLinkedList`1.ContainsCount(`0)">
\r
3612 Count the number of items of the collection equal to a particular value.
\r
3613 Returns 0 if and only if the value is not in the collection.
\r
3615 <param name="item">The value to count.</param>
\r
3616 <returns>The number of copies found.</returns>
\r
3618 <member name="M:C5.HashedLinkedList`1.RemoveAllCopies(`0)">
\r
3620 Remove all items equivalent to a given value.
\r
3622 <param name="item">The value to remove.</param>
\r
3624 <member name="M:C5.HashedLinkedList`1.Add(`0)">
\r
3626 Add an item to this collection if possible. Since this collection has set
\r
3627 semantics, the item will be added if not already in the collection.
\r
3629 <param name="item">The item to add.</param>
\r
3630 <returns>True if item was added.</returns>
\r
3632 <member name="M:C5.HashedLinkedList`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
3634 Add the elements from another collection to this collection.
\r
3635 Only items not already in the collection
\r
3638 <param name="items">The items to add.</param>
\r
3640 <member name="M:C5.HashedLinkedList`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
3642 Add the elements from another collection with a more specialized item type
\r
3643 to this collection.
\r
3644 Only items not already in the collection
\r
3647 <typeparam name="U">The type of items to add</typeparam>
\r
3648 <param name="items">The items to add</param>
\r
3650 <member name="M:C5.HashedLinkedList`1.Check">
\r
3652 Check the integrity of the internal data structures of this collection.
\r
3653 Only avaliable in DEBUG builds???
\r
3655 <returns>True if check does not fail.</returns>
\r
3657 <member name="P:C5.HashedLinkedList`1.Item(System.Int32)">
\r
3659 On this list, this indexer is read/write.
\r
3660 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
3661 >= the size of the collection.
\r
3663 <value>The i'th item of this list.</value>
\r
3664 <param name="i">The index of the item to fetch or store.</param>
\r
3666 <member name="P:C5.HashedLinkedList`1.ContainsSpeed">
\r
3668 The value is symbolic indicating the type of asymptotic complexity
\r
3669 in terms of the size of this collection (worst-case or amortized as
\r
3672 <value>Speed.Constant</value>
\r
3674 <member name="P:C5.HashedLinkedList`1.AllowsDuplicates">
\r
3678 <value>False since this collection has set semantics.</value>
\r
3680 <member name="T:C5.KeyValuePair`2">
\r
3682 An entry in a dictionary from K to V.
\r
3685 <member name="F:C5.KeyValuePair`2.key">
\r
3687 The key field of the entry
\r
3690 <member name="F:C5.KeyValuePair`2.value">
\r
3692 The value field of the entry
\r
3695 <member name="M:C5.KeyValuePair`2.#ctor(`0,`1)">
\r
3697 Create an entry with specified key and value
\r
3699 <param name="k">The key</param>
\r
3700 <param name="v">The value</param>
\r
3702 <member name="M:C5.KeyValuePair`2.#ctor(`0)">
\r
3704 Create an entry with a specified key. The value is undefined.
\r
3706 <param name="k">The key</param>
\r
3708 <member name="M:C5.KeyValuePair`2.ToString">
\r
3710 Pretty print an entry
\r
3712 <returns>(key, value)</returns>
\r
3714 <member name="M:C5.KeyValuePair`2.Equals(System.Object)">
\r
3716 Check equality of entries
\r
3718 <param name="obj">The other object</param>
\r
3719 <returns>True if obj is an entry of the same type and has the same key</returns>
\r
3721 <member name="M:C5.KeyValuePair`2.GetHashCode">
\r
3723 Get the hash code of the key.
\r
3725 <returns>The hash code</returns>
\r
3727 <member name="T:C5.KeyValuePairComparer`2">
\r
3729 Default comparer for dictionary entries in a sorted dictionary.
\r
3730 Entry comparisons only look at keys.
\r
3733 <member name="M:C5.KeyValuePairComparer`2.#ctor(C5.IComparer{`0})">
\r
3735 Create an entry comparer for a item comparer of the keys
\r
3737 <param name="c">Comparer of keys</param>
\r
3739 <member name="M:C5.KeyValuePairComparer`2.Compare(C5.KeyValuePair{`0,`1},C5.KeyValuePair{`0,`1})">
\r
3741 Compare two entries
\r
3743 <param name="a">First entry</param>
\r
3744 <param name="b">Second entry</param>
\r
3745 <returns>The result of comparing the keys</returns>
\r
3747 <member name="T:C5.KeyValuePairHasher`2">
\r
3749 Default hasher for dictionary entries.
\r
3750 Operations only look at keys.
\r
3753 <member name="M:C5.KeyValuePairHasher`2.#ctor">
\r
3755 Create an entry hasher using the default hasher for keys
\r
3758 <member name="M:C5.KeyValuePairHasher`2.#ctor(C5.IHasher{`0})">
\r
3760 Create an entry hasher from a specified item hasher for the keys
\r
3762 <param name="c">The key hasher</param>
\r
3764 <member name="M:C5.KeyValuePairHasher`2.GetHashCode(C5.KeyValuePair{`0,`1})">
\r
3766 Get the hash code of the entry
\r
3768 <param name="item">The entry</param>
\r
3769 <returns>The hash code of the key</returns>
\r
3771 <member name="M:C5.KeyValuePairHasher`2.Equals(C5.KeyValuePair{`0,`1},C5.KeyValuePair{`0,`1})">
\r
3773 Test two entries for equality
\r
3775 <param name="i1">First entry</param>
\r
3776 <param name="i2">Second entry</param>
\r
3777 <returns>True if keys are equal</returns>
\r
3779 <member name="T:C5.TreeSet`1">
\r
3781 An implementation of Red-Black trees as an indexed, sorted collection with set semantics,
\r
3782 cf. <a href="litterature.htm#CLRS">CLRS</a>. <see cref="T:C5.TreeBag!1"/> for a version
\r
3783 with bag semantics. <see cref="T:C5.TreeDictionary!2"/> for a sorted dictionary
\r
3784 based on this tree implementation.
\r
3786 The comparer (sorting order) may be either natural, because the item type is comparable
\r
3787 (generic: <see cref="T:C5.IComparable!1"/> or non-generic: System.IComparable) or it can
\r
3788 be external and supplied by the user in the constructor.</p>
\r
3790 <p><i>TODO: describe performance here</i></p>
\r
3791 <p><i>TODO: discuss persistence and its useful usage modes. Warn about the space
\r
3792 leak possible with other usage modes.</i></p>
\r
3795 <member name="M:C5.TreeSet`1.left(C5.TreeSet{`0}.Node)">
\r
3797 Fetch the left child of n taking node-copying persistence into
\r
3798 account if relevant.
\r
3800 <param name="n"></param>
\r
3801 <returns></returns>
\r
3803 <member name="M:C5.TreeSet`1.#ctor">
\r
3805 Create a red-black tree collection with natural comparer and item hasher.
\r
3808 <member name="M:C5.TreeSet`1.#ctor(C5.IComparer{`0})">
\r
3810 Create a red-black tree collection with an external comparer (and natural item hasher,
\r
3811 assumed consistent).
\r
3813 <param name="c">The external comparer</param>
\r
3815 <member name="M:C5.TreeSet`1.#ctor(C5.IComparer{`0},C5.IHasher{`0})">
\r
3817 Create a red-black tree collection with an external comparer aand an external
\r
3818 item hasher, assumed consistent.
\r
3820 <param name="c">The external comparer</param>
\r
3821 <param name="h">The external item hasher</param>
\r
3823 <member name="M:C5.TreeSet`1.GetEnumerator">
\r
3825 Create an enumerator for this tree
\r
3827 <returns>The enumerator</returns>
\r
3829 <member name="M:C5.TreeSet`1.addIterative(`0,`0@,System.Boolean,System.Boolean@)">
\r
3831 Add item to tree. If already there, return the found item in the second argument.
\r
3833 <param name="item">Item to add</param>
\r
3834 <param name="founditem">item found</param>
\r
3835 <param name="update">whether item in node should be updated</param>
\r
3836 <param name="wasfound">true if found in bag, false if not found or tre is a set</param>
\r
3837 <returns>True if item was added</returns>
\r
3839 <member name="M:C5.TreeSet`1.Add(`0)">
\r
3841 Add an item to this collection if possible. If this collection has set
\r
3842 semantics, the item will be added if not already in the collection. If
\r
3843 bag semantics, the item will always be added.
\r
3845 <param name="item">The item to add.</param>
\r
3846 <returns>True if item was added.</returns>
\r
3848 <member name="M:C5.TreeSet`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
3850 Add the elements from another collection to this collection. If this
\r
3851 collection has set semantics, only items not already in the collection
\r
3854 <param name="items">The items to add.</param>
\r
3856 <member name="M:C5.TreeSet`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
3858 Add the elements from another collection with a more specialized item type
\r
3859 to this collection. If this
\r
3860 collection has set semantics, only items not already in the collection
\r
3863 <typeparam name="U">The type of items to add</typeparam>
\r
3864 <param name="items">The items to add</param>
\r
3866 <member name="M:C5.TreeSet`1.AddSorted(System.Collections.Generic.IEnumerable{`0})">
\r
3868 Add all the items from another collection with an enumeration order that
\r
3869 is increasing in the items. <para>The idea is that the implementation may use
\r
3870 a faster algorithm to merge the two collections.</para>
\r
3871 <exception cref="T:System.ArgumentException"/> if the enumerated items turns out
\r
3872 not to be in increasing order.
\r
3874 <param name="items">The collection to add.</param>
\r
3876 <member name="M:C5.TreeSet`1.Contains(`0)">
\r
3878 Check if this collection contains (an item equivalent to according to the
\r
3879 itemhasher) a particular value.
\r
3881 <param name="item">The value to check for.</param>
\r
3882 <returns>True if the items is in this collection.</returns>
\r
3884 <member name="M:C5.TreeSet`1.Find(`0@)">
\r
3886 Check if this collection contains an item equivalent according to the
\r
3887 itemhasher to a particular value. If so, return in the ref argument (a
\r
3888 binary copy of) the actual value found.
\r
3890 <param name="item">The value to look for.</param>
\r
3891 <returns>True if the items is in this collection.</returns>
\r
3893 <member name="M:C5.TreeSet`1.FindOrAdd(`0@)">
\r
3895 Find or add the item to the tree. If the tree does not contain
\r
3896 an item equivalent to this item add it, else return the exisiting
\r
3897 one in the ref argument.
\r
3900 <param name="item"></param>
\r
3901 <returns>True if item was found</returns>
\r
3903 <member name="M:C5.TreeSet`1.Update(`0)">
\r
3905 Check if this collection contains an item equivalent according to the
\r
3906 itemhasher to a particular value. If so, update the item in the collection
\r
3907 to with a binary copy of the supplied value. If the collection has bag semantics,
\r
3908 this updates all equivalent copies in
\r
3911 <param name="item">Value to update.</param>
\r
3912 <returns>True if the item was found and hence updated.</returns>
\r
3914 <member name="M:C5.TreeSet`1.UpdateOrAdd(`0)">
\r
3916 Check if this collection contains an item equivalent according to the
\r
3917 itemhasher to a particular value. If so, update the item in the collection
\r
3918 to with a binary copy of the supplied value; else add the value to the collection.
\r
3920 <p>NOTE: the bag implementation is currently wrong!</p>
\r
3922 <param name="item">Value to add or update.</param>
\r
3923 <returns>True if the item was found and updated (hence not added).</returns>
\r
3925 <member name="M:C5.TreeSet`1.Remove(`0)">
\r
3927 Remove a particular item from this collection. If the collection has bag
\r
3928 semantics only one copy equivalent to the supplied item is removed.
\r
3930 <param name="item">The value to remove.</param>
\r
3931 <returns>True if the item was found (and removed).</returns>
\r
3933 <member name="M:C5.TreeSet`1.RemoveWithReturn(`0@)">
\r
3935 Remove a particular item from this collection if found. If the collection
\r
3936 has bag semantics only one copy equivalent to the supplied item is removed,
\r
3937 which one is implementation dependent.
\r
3938 If an item was removed, report a binary copy of the actual item removed in
\r
3941 <param name="item">The value to remove on input.</param>
\r
3942 <returns>True if the item was found (and removed).</returns>
\r
3944 <member name="M:C5.TreeSet`1.Clear">
\r
3946 Remove all items from this collection.
\r
3949 <member name="M:C5.TreeSet`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
3951 Remove all items in another collection from this one. If this collection
\r
3952 has bag semantics, take multiplicities into account.
\r
3954 <param name="items">The items to remove.</param>
\r
3956 <member name="M:C5.TreeSet`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
3958 Remove all items not in some other collection from this one. If this collection
\r
3959 has bag semantics, take multiplicities into account.
\r
3961 <param name="items">The items to retain.</param>
\r
3963 <member name="M:C5.TreeSet`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
3965 Check if this collection contains all the values in another collection.
\r
3966 If this collection has bag semantics (<code>NoDuplicates==false</code>)
\r
3967 the check is made with respect to multiplicities, else multiplicities
\r
3968 are not taken into account.
\r
3970 <param name="items">The </param>
\r
3971 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
3973 <member name="M:C5.TreeSet`1.FindAll(C5.Filter{`0})">
\r
3975 Create a new indexed sorted collection consisting of the items of this
\r
3976 indexed sorted collection satisfying a certain predicate.
\r
3978 <param name="filter">The filter delegate defining the predicate.</param>
\r
3979 <returns>The new indexed sorted collection.</returns>
\r
3981 <member name="M:C5.TreeSet`1.Map``1(C5.Mapper{`0,``0},C5.IComparer{``0})">
\r
3983 Create a new indexed sorted collection consisting of the results of
\r
3984 mapping all items of this list.
\r
3985 <exception cref="T:System.ArgumentException"/> if the map is not increasing over
\r
3986 the items of this collection (with respect to the two given comparison
\r
3989 <param name="mapper">The delegate definging the map.</param>
\r
3990 <param name="c">The comparion relation to use for the result.</param>
\r
3991 <returns>The new sorted collection.</returns>
\r
3993 <member name="M:C5.TreeSet`1.ContainsCount(`0)">
\r
3995 Count the number of items of the collection equal to a particular value.
\r
3996 Returns 0 if and only if the value is not in the collection.
\r
3998 <param name="item">The value to count.</param>
\r
3999 <returns>The number of copies found.</returns>
\r
4001 <member name="M:C5.TreeSet`1.RemoveAllCopies(`0)">
\r
4003 Remove all items equivalent to a given value.
\r
4005 <param name="item">The value to remove.</param>
\r
4007 <member name="M:C5.TreeSet`1.IndexOf(`0)">
\r
4009 Searches for an item in the list going forwrds from the start.
\r
4011 <param name="item">Item to search for.</param>
\r
4012 <returns>Index of item from start.</returns>
\r
4014 <member name="M:C5.TreeSet`1.LastIndexOf(`0)">
\r
4016 Searches for an item in the list going backwords from the end.
\r
4018 <param name="item">Item to search for.</param>
\r
4019 <returns>Index of of item from the end.</returns>
\r
4021 <member name="M:C5.TreeSet`1.RemoveAt(System.Int32)">
\r
4023 Remove the item at a specific position of the list.
\r
4024 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
4025 >= the size of the collection.
\r
4027 <param name="i">The index of the item to remove.</param>
\r
4028 <returns>The removed item.</returns>
\r
4030 <member name="M:C5.TreeSet`1.RemoveInterval(System.Int32,System.Int32)">
\r
4032 Remove all items in an index interval.
\r
4033 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
4035 <param name="start">The index of the first item to remove.</param>
\r
4036 <param name="count">The number of items to remove.</param>
\r
4038 <member name="M:C5.TreeSet`1.Backwards">
\r
4040 Create a collection containing the same items as this collection, but
\r
4041 whose enumerator will enumerate the items backwards. The new collection
\r
4042 will become invalid if the original is modified. Method typicaly used as in
\r
4043 <code>foreach (T x in coll.Backwards()) {...}</code>
\r
4045 <returns>The backwards collection.</returns>
\r
4047 <member name="M:C5.TreeSet`1.FindMin">
\r
4049 Find the current least item of this priority queue.
\r
4051 <returns>The least item.</returns>
\r
4053 <member name="M:C5.TreeSet`1.DeleteMin">
\r
4055 Remove the least item from this priority queue.
\r
4057 <returns>The removed item.</returns>
\r
4059 <member name="M:C5.TreeSet`1.FindMax">
\r
4061 Find the current largest item of this priority queue.
\r
4063 <returns>The largest item.</returns>
\r
4065 <member name="M:C5.TreeSet`1.DeleteMax">
\r
4067 Remove the largest item from this priority queue.
\r
4069 <returns>The removed item.</returns>
\r
4071 <member name="M:C5.TreeSet`1.Predecessor(`0)">
\r
4073 Find the strict predecessor in the sorted collection of a particular value,
\r
4074 i.e. the largest item in the collection less than the supplied value.
\r
4075 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
4076 supplied value is less than or equal to the minimum of this collection.)
\r
4078 <param name="item">The item to find the predecessor for.</param>
\r
4079 <returns>The predecessor.</returns>
\r
4081 <member name="M:C5.TreeSet`1.WeakPredecessor(`0)">
\r
4083 Find the weak predecessor in the sorted collection of a particular value,
\r
4084 i.e. the largest item in the collection less than or equal to the supplied value.
\r
4085 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
4086 supplied value is less than the minimum of this collection.)
\r
4088 <param name="item">The item to find the weak predecessor for.</param>
\r
4089 <returns>The weak predecessor.</returns>
\r
4091 <member name="M:C5.TreeSet`1.Successor(`0)">
\r
4093 Find the strict successor in the sorted collection of a particular value,
\r
4094 i.e. the least item in the collection greater than the supplied value.
\r
4095 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
4096 supplied value is greater than or equal to the maximum of this collection.)
\r
4098 <param name="item">The item to find the successor for.</param>
\r
4099 <returns>The successor.</returns>
\r
4101 <member name="M:C5.TreeSet`1.WeakSuccessor(`0)">
\r
4103 Find the weak successor in the sorted collection of a particular value,
\r
4104 i.e. the least item in the collection greater than or equal to the supplied value.
\r
4105 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
4106 supplied value is greater than the maximum of this collection.)
\r
4108 <param name="item">The item to find the weak successor for.</param>
\r
4109 <returns>The weak successor.</returns>
\r
4111 <member name="M:C5.TreeSet`1.RangeFrom(`0)">
\r
4113 Query this sorted collection for items greater than or equal to a supplied value.
\r
4115 <param name="bot">The lower bound (inclusive).</param>
\r
4116 <returns>The result directed collection.</returns>
\r
4118 <member name="M:C5.TreeSet`1.RangeFromTo(`0,`0)">
\r
4120 Query this sorted collection for items between two supplied values.
\r
4122 <param name="bot">The lower bound (inclusive).</param>
\r
4123 <param name="top">The upper bound (exclusive).</param>
\r
4124 <returns>The result directed collection.</returns>
\r
4126 <member name="M:C5.TreeSet`1.RangeTo(`0)">
\r
4128 Query this sorted collection for items less than a supplied value.
\r
4130 <param name="top">The upper bound (exclusive).</param>
\r
4131 <returns>The result directed collection.</returns>
\r
4133 <member name="M:C5.TreeSet`1.RangeAll">
\r
4135 Create a directed collection with the same items as this collection.
\r
4137 <returns>The result directed collection.</returns>
\r
4139 <member name="M:C5.TreeSet`1.Cut(System.IComparable{`0},`0@,System.Boolean@,`0@,System.Boolean@)">
\r
4141 Perform a search in the sorted collection for the ranges in which a
\r
4142 non-decreasing function from the item type to <code>int</code> is
\r
4143 negative, zero respectively positive. If the supplied cut function is
\r
4144 not non-decreasing, the result of this call is undefined.
\r
4146 <param name="c">The cut function <code>T</code> to <code>int</code>, given
\r
4147 as an <code>IComparable<T></code> object, where the cut function is
\r
4148 the <code>c.CompareTo(T that)</code> method.</param>
\r
4149 <param name="low">Returns the largest item in the collection, where the
\r
4150 cut function is negative (if any).</param>
\r
4151 <param name="lowIsValid">True if the cut function is negative somewhere
\r
4152 on this collection.</param>
\r
4153 <param name="high">Returns the least item in the collection, where the
\r
4154 cut function is positive (if any).</param>
\r
4155 <param name="highIsValid">True if the cut function is positive somewhere
\r
4156 on this collection.</param>
\r
4157 <returns></returns>
\r
4159 <member name="M:C5.TreeSet`1.CountFrom(`0)">
\r
4161 Determine the number of items at or above a supplied threshold.
\r
4163 <param name="bot">The lower bound (inclusive)</param>
\r
4164 <returns>The number of matcing items.</returns>
\r
4166 <member name="M:C5.TreeSet`1.CountFromTo(`0,`0)">
\r
4168 Determine the number of items between two supplied thresholds.
\r
4170 <param name="bot">The lower bound (inclusive)</param>
\r
4171 <param name="top">The upper bound (exclusive)</param>
\r
4172 <returns>The number of matcing items.</returns>
\r
4174 <member name="M:C5.TreeSet`1.CountTo(`0)">
\r
4176 Determine the number of items below a supplied threshold.
\r
4178 <param name="top">The upper bound (exclusive)</param>
\r
4179 <returns>The number of matcing items.</returns>
\r
4181 <member name="M:C5.TreeSet`1.RemoveRangeFrom(`0)">
\r
4183 Remove all items of this collection above or at a supplied threshold.
\r
4185 <param name="low">The lower threshold (inclusive).</param>
\r
4187 <member name="M:C5.TreeSet`1.RemoveRangeFromTo(`0,`0)">
\r
4189 Remove all items of this collection between two supplied thresholds.
\r
4191 <param name="low">The lower threshold (inclusive).</param>
\r
4192 <param name="hi">The upper threshold (exclusive).</param>
\r
4194 <member name="M:C5.TreeSet`1.RemoveRangeTo(`0)">
\r
4196 Remove all items of this collection below a supplied threshold.
\r
4198 <param name="hi">The upper threshold (exclusive).</param>
\r
4200 <member name="M:C5.TreeSet`1.Dispose">
\r
4202 If this tree is a snapshot, remove registration in base tree
\r
4205 <member name="M:C5.TreeSet`1.Finalize">
\r
4207 If this tree is a snapshot, remove registration in base tree
\r
4210 <member name="M:C5.TreeSet`1.Snapshot">
\r
4212 Make a (read-only) snap shot of this collection.
\r
4214 <returns>The snap shot.</returns>
\r
4216 <member name="M:C5.TreeSet`1.minidump(C5.TreeSet{`0}.Node,System.String)">
\r
4218 Display this node on the console, and recursively its subnodes.
\r
4220 <param name="n">Node to display</param>
\r
4221 <param name="space">Indentation</param>
\r
4223 <member name="M:C5.TreeSet`1.dump">
\r
4225 Print the tree structure to the console stdout.
\r
4228 <member name="M:C5.TreeSet`1.dump(System.String)">
\r
4230 Print the tree structure to the console stdout.
\r
4233 <member name="M:C5.TreeSet`1.dump(System.String,System.String)">
\r
4235 Display this tree on the console.
\r
4237 <param name="msg">Identifying string of this call to dump</param>
\r
4238 <param name="err">Extra (error)message to include</param>
\r
4240 <member name="M:C5.TreeSet`1.massert(System.Boolean,C5.TreeSet{`0}.Node,System.String,System.IO.TextWriter)">
\r
4242 Print warning m on o if b is false.
\r
4244 <param name="b">Condition that should hold</param>
\r
4245 <param name="n">Place (used for id display)</param>
\r
4246 <param name="m">Message</param>
\r
4247 <param name="o">Output stream</param>
\r
4248 <returns>b</returns>
\r
4250 <member name="M:C5.TreeSet`1.Check(System.String)">
\r
4252 Checks red-black invariant. Dumps tree to console if bad
\r
4254 <param name="name">Title of dump</param>
\r
4255 <returns>false if invariant violation</returns>
\r
4257 <member name="M:C5.TreeSet`1.Check">
\r
4259 Checks red-black invariant. Dumps tree to console if bad
\r
4261 <returns>false if invariant violation</returns>
\r
4263 <member name="P:C5.TreeSet`1.Features">
\r
4265 A debugging aid for making the selected compilation alternatives
\r
4266 available to the user. (To be removed when selection is finally fixed
\r
4267 for production version).
\r
4270 <member name="P:C5.TreeSet`1.AllowsDuplicates">
\r
4271 <summary></summary>
\r
4272 <value>False since this tree has set semantics.</value>
\r
4274 <member name="P:C5.TreeSet`1.ContainsSpeed">
\r
4276 The value is symbolic indicating the type of asymptotic complexity
\r
4277 in terms of the size of this collection (worst-case or amortized as
\r
4280 <value>Speed.Log</value>
\r
4282 <member name="P:C5.TreeSet`1.Item(System.Int32)">
\r
4284 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
4285 >= the size of the collection.
\r
4287 <value>The i'th item of this list.</value>
\r
4288 <param name="i">the index to lookup</param>
\r
4290 <member name="P:C5.TreeSet`1.Item(System.Int32,System.Int32)">
\r
4292 <exception cref="T:System.IndexOutOfRangeException"/>.
\r
4294 <value>The directed collection of items in a specific index interval.</value>
\r
4295 <param name="start">The low index of the interval (inclusive).</param>
\r
4296 <param name="end">The high index of the interval (exclusive).</param>
\r
4298 <member name="P:C5.TreeSet`1.Comparer">
\r
4300 The comparer object supplied at creation time for this collection
\r
4302 <value>The comparer</value>
\r
4304 <member name="T:C5.TreeSet`1.Feature">
\r
4306 A debugging aid for making the selected compilation alternatives
\r
4307 available to the user. (To be removed when selection is finally fixed
\r
4308 for production version).
\r
4311 <member name="F:C5.TreeSet`1.Feature.Dummy">
\r
4316 <member name="F:C5.TreeSet`1.Feature.NodeCopyPersistence">
\r
4318 Node copy persistence as explained in <a href="litterature.htm#Tarjan1">Tarjan1</a>
\r
4321 <member name="F:C5.TreeSet`1.Feature.Sizes">
\r
4323 Maintain sub tree sizes
\r
4326 <member name="F:C5.TreeSet`1.Feature.Heights">
\r
4328 Maintain precise node heights
\r
4331 <member name="F:C5.TreeSet`1.Feature.Ranks">
\r
4333 Maintain node ranks (~ black height)
\r
4336 <member name="F:C5.TreeSet`1.Feature.Traceid">
\r
4338 Maintain unique ids on tree nodes.
\r
4341 <member name="T:C5.TreeSet`1.Node">
\r
4343 The type of node in a Red-Black binary tree
\r
4346 <member name="M:C5.TreeSet`1.Node.update(C5.TreeSet{`0}.Node@,System.Boolean,C5.TreeSet{`0}.Node,System.Int32,System.Int32)">
\r
4348 Update a child pointer
\r
4350 <param name="cursor"></param>
\r
4351 <param name="leftnode"></param>
\r
4352 <param name="child"></param>
\r
4353 <param name="maxsnapid"></param>
\r
4354 <param name="generation"></param>
\r
4355 <returns>True if node was *copied*</returns>
\r
4357 <member name="T:C5.TreeSet`1.Enumerator">
\r
4359 An enumerator for a red-black tree collection. Based on an explicit stack
\r
4360 of subtrees waiting to be enumerated. Currently only used for the tree set
\r
4361 enumerators (tree bag enumerators use an iterator block based enumerator).
\r
4364 <member name="M:C5.TreeSet`1.Enumerator.#ctor(C5.TreeSet{`0})">
\r
4366 Create a tree enumerator
\r
4368 <param name="tree">The red-black tree to enumerate</param>
\r
4370 <member name="M:C5.TreeSet`1.Enumerator.MoveNext">
\r
4372 Move enumerator to next item in tree, or the first item if
\r
4373 this is the first call to MoveNext.
\r
4374 <exception cref="T:System.InvalidOperationException"/> if underlying tree was modified.
\r
4376 <returns>True if enumerator is valid now</returns>
\r
4378 <member name="M:C5.TreeSet`1.Enumerator.Dispose">
\r
4380 Call Dispose(true) and then suppress finalization of this enumerator.
\r
4383 <member name="M:C5.TreeSet`1.Enumerator.Dispose(System.Boolean)">
\r
4385 Remove the internal data (notably the stack array).
\r
4387 <param name="disposing">True if called from Dispose(),
\r
4388 false if called from the finalizer</param>
\r
4390 <member name="M:C5.TreeSet`1.Enumerator.Finalize">
\r
4392 Finalizer for enumeratir
\r
4395 <member name="P:C5.TreeSet`1.Enumerator.Current">
\r
4397 Undefined if enumerator is not valid (MoveNext hash been called returning true)
\r
4399 <value>The current item of the enumerator.</value>
\r
4401 <member name="T:C5.TreeSet`1.SnapEnumerator">
\r
4403 An enumerator for a snapshot of a node copy persistent red-black tree
\r
4407 <member name="M:C5.TreeSet`1.SnapEnumerator.#ctor(C5.TreeSet{`0})">
\r
4409 Creta an enumerator for a snapshot of a node copy persistent red-black tree
\r
4412 <param name="tree">The snapshot</param>
\r
4414 <member name="M:C5.TreeSet`1.SnapEnumerator.MoveNext">
\r
4416 Move enumerator to next item in tree, or the first item if
\r
4417 this is the first call to MoveNext.
\r
4418 <exception cref="T:System.InvalidOperationException"/> if underlying tree was modified.
\r
4420 <returns>True if enumerator is valid now</returns>
\r
4422 <member name="P:C5.TreeSet`1.SnapEnumerator.Current">
\r
4424 Undefined if enumerator is not valid (MoveNext hash been called returning true)
\r
4426 <value>The current value of the enumerator.</value>
\r
4428 <member name="M:C5.TreeSet`1.Range.Enumerator.MoveNext">
\r
4430 Move enumerator to next item in tree, or the first item if
\r
4431 this is the first call to MoveNext.
\r
4432 <exception cref="T:System.InvalidOperationException"/> if underlying tree was modified.
\r
4434 <returns>True if enumerator is valid now</returns>
\r
4436 <member name="P:C5.TreeSet`1.Range.Enumerator.Current">
\r
4438 Undefined if enumerator is not valid (MoveNext hash been called returning true)
\r
4440 <value>The current value of the enumerator.</value>
\r
4442 <member name="T:C5.IntervalHeap`1">
\r
4444 A priority queue class based on an interval heap data structure.
\r
4447 <member name="M:C5.IntervalHeap`1.#ctor">
\r
4449 Create an interval heap with natural item comparer and default initial capacity (16)
\r
4452 <member name="M:C5.IntervalHeap`1.#ctor(C5.IComparer{`0})">
\r
4454 Create an interval heap with external item comparer and default initial capacity (16)
\r
4456 <param name="c">The external comparer</param>
\r
4458 <member name="M:C5.IntervalHeap`1.#ctor(System.Int32)">
\r
4460 Create an interval heap with natural item comparer and prescribed initial capacity
\r
4462 <param name="capacity">The initial capacity</param>
\r
4464 <member name="M:C5.IntervalHeap`1.#ctor(C5.IComparer{`0},System.Int32)">
\r
4466 Create an interval heap with external item comparer and prescribed initial capacity
\r
4468 <param name="c">The external comparer</param>
\r
4469 <param name="capacity">The initial capacity</param>
\r
4471 <member name="M:C5.IntervalHeap`1.FindMin">
\r
4473 Find the current least item of this priority queue.
\r
4474 <exception cref="T:System.InvalidOperationException"/> if queue is empty
\r
4476 <returns>The least item.</returns>
\r
4478 <member name="M:C5.IntervalHeap`1.DeleteMin">
\r
4480 Remove the least item from this priority queue.
\r
4481 <exception cref="T:System.InvalidOperationException"/> if queue is empty
\r
4483 <returns>The removed item.</returns>
\r
4485 <member name="M:C5.IntervalHeap`1.FindMax">
\r
4487 Find the current largest item of this priority queue.
\r
4488 <exception cref="T:System.InvalidOperationException"/> if queue is empty
\r
4490 <returns>The largest item.</returns>
\r
4492 <member name="M:C5.IntervalHeap`1.DeleteMax">
\r
4494 Remove the largest item from this priority queue.
\r
4495 <exception cref="T:System.InvalidOperationException"/> if queue is empty
\r
4497 <returns>The removed item.</returns>
\r
4499 <member name="M:C5.IntervalHeap`1.Add(`0)">
\r
4501 Add an item to this priority queue.
\r
4503 <param name="item">The item to add.</param>
\r
4504 <returns>True</returns>
\r
4506 <member name="M:C5.IntervalHeap`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
4508 Add the elements from another collection to this collection.
\r
4510 <param name="items">The items to add.</param>
\r
4512 <member name="M:C5.IntervalHeap`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
4514 Add the elements from another collection with a more specialized item type
\r
4515 to this collection.
\r
4517 <typeparam name="U">The type of items to add</typeparam>
\r
4518 <param name="items">The items to add</param>
\r
4520 <member name="M:C5.IntervalHeap`1.GetEnumerator">
\r
4522 Create an enumerator for the collection
\r
4523 <para>Note: the enumerator does *not* enumerate the items in sorted order,
\r
4524 but in the internal table order.</para>
\r
4526 <returns>The enumerator(SIC)</returns>
\r
4528 <member name="M:C5.IntervalHeap`1.Check">
\r
4530 Check the integrity of the internal data structures of this collection.
\r
4531 Only avaliable in DEBUG builds???
\r
4533 <returns>True if check does not fail.</returns>
\r
4535 <member name="P:C5.IntervalHeap`1.Comparer">
\r
4537 The comparer object supplied at creation time for this collection
\r
4539 <value>The comparer</value>
\r
4541 <member name="P:C5.IntervalHeap`1.AllowsDuplicates">
\r
4545 <value>True since this collection has bag semantics</value>
\r
4547 <member name="P:C5.IntervalHeap`1.SyncRoot">
\r
4551 <value>The distinguished object to use for locking to synchronize multithreaded access</value>
\r
4553 <member name="P:C5.IntervalHeap`1.IsEmpty">
\r
4557 <value>True if this collection is empty.</value>
\r
4559 <member name="P:C5.IntervalHeap`1.Count">
\r
4563 <value>The size of this collection</value>
\r
4565 <member name="P:C5.IntervalHeap`1.CountSpeed">
\r
4567 The value is symbolic indicating the type of asymptotic complexity
\r
4568 in terms of the size of this collection (worst-case or amortized as
\r
4571 <value>A characterization of the speed of the
\r
4572 <code>Count</code> property in this collection.</value>
\r
4574 <member name="T:C5.HashDictionary`2">
\r
4576 A generic dictionary class based on a hash set class <see cref="T:C5.HashSet!1"/>.
\r
4579 <member name="M:C5.HashDictionary`2.#ctor">
\r
4581 Create a hash dictionary using a default hasher for the keys.
\r
4582 Initial capacity of internal table will be 16 entries and threshold for
\r
4583 expansion is 66% fill.
\r
4586 <member name="M:C5.HashDictionary`2.#ctor(C5.IHasher{`0})">
\r
4588 Create a hash dictionary using a custom hasher for the keys.
\r
4589 Initial capacity of internal table will be 16 entries and threshold for
\r
4590 expansion is 66% fill.
\r
4592 <param name="h">The external key hasher</param>
\r
4594 <member name="M:C5.HashDictionary`2.#ctor(System.Int32,System.Double,C5.IHasher{`0})">
\r
4596 Create a hash dictionary using a custom hasher and prescribing the
\r
4597 initial size of the dictionary and a non-default threshold for internal table expansion.
\r
4599 <param name="capacity">The initial capacity. Will be rounded upwards to nearest
\r
4600 power of 2, at least 16.</param>
\r
4601 <param name="fill">The expansion threshold. Must be between 10% and 90%.</param>
\r
4602 <param name="h">The external key hasher</param>
\r
4604 <member name="T:C5.ArrayList`1">
\r
4606 A list collection based on a plain dynamic array data structure.
\r
4607 Expansion of the internal array is performed by doubling on demand.
\r
4608 The internal array is only shrinked by the Clear method.
\r
4610 <p>When the FIFO property is set to false this class works fine as a stack of T.
\r
4611 When the FIFO property is set to true the class will function as a (FIFO) queue
\r
4612 but very inefficiently, use a LinkedList (<see cref="T:C5.LinkedList!1"/>) instead.</p>
\r
4615 <member name="F:C5.ArrayList`1.underlying">
\r
4617 The underlying list if we are a view, null else.
\r
4620 <member name="F:C5.ArrayList`1.underlyingsize">
\r
4622 The size of the underlying list.
\r
4625 <member name="F:C5.ArrayList`1.fIFO">
\r
4627 The underlying field of the FIFO property
\r
4630 <member name="M:C5.ArrayList`1.expand">
\r
4632 Double the size of the internal array.
\r
4635 <member name="M:C5.ArrayList`1.expand(System.Int32,System.Int32)">
\r
4637 Expand the internal array, resetting the index of the first unused element.
\r
4639 <param name="newcapacity">The new capacity (will be rouded upwards to a power of 2).</param>
\r
4640 <param name="newsize">The new count of </param>
\r
4642 <member name="M:C5.ArrayList`1.updatecheck">
\r
4644 Check if it is valid to perform updates and increment stamp.
\r
4645 <exception cref="T:System.InvalidOperationException"/> if check fails.
\r
4648 <member name="M:C5.ArrayList`1.modifycheck">
\r
4650 Check if we are a view that the underlying list has only been updated through us.
\r
4651 <exception cref="T:System.InvalidOperationException"/> if check fails.
\r
4653 This method should be called from enumerators etc to guard against
\r
4654 modification of the base collection.
\r
4657 <member name="M:C5.ArrayList`1.modifycheck(System.Int32)">
\r
4659 Check that the list has not been updated since a particular time.
\r
4660 <exception cref="T:System.InvalidOperationException"/> if check fails.
\r
4662 <param name="stamp">The stamp indicating the time.</param>
\r
4664 <member name="M:C5.ArrayList`1.addtosize(System.Int32)">
\r
4666 Increment or decrement the private size fields
\r
4668 <param name="delta">Increment (with sign)</param>
\r
4670 <member name="M:C5.ArrayList`1.indexOf(`0)">
\r
4672 Internal version of IndexOf without modification checks.
\r
4674 <param name="item">Item to look for</param>
\r
4675 <returns>The index of first occurrence</returns>
\r
4677 <member name="M:C5.ArrayList`1.lastIndexOf(`0)">
\r
4679 Internal version of LastIndexOf without modification checks.
\r
4681 <param name="item">Item to look for</param>
\r
4682 <returns>The index of last occurrence</returns>
\r
4684 <member name="M:C5.ArrayList`1.insert(System.Int32,`0)">
\r
4686 Internal version of Insert with no modification checks.
\r
4688 <param name="i">Index to insert at</param>
\r
4689 <param name="item">Item to insert</param>
\r
4691 <member name="M:C5.ArrayList`1.removeAt(System.Int32)">
\r
4693 Internal version of RemoveAt with no modification checks.
\r
4695 <param name="i">Index to remove at</param>
\r
4696 <returns>The removed item</returns>
\r
4698 <member name="M:C5.ArrayList`1.#ctor">
\r
4700 Create an array list with default item hasher and initial capacity 8 items.
\r
4703 <member name="M:C5.ArrayList`1.#ctor(C5.IHasher{`0})">
\r
4705 Create an array list with external item hasher and initial capacity 8 items.
\r
4707 <param name="hasher">The external hasher</param>
\r
4709 <member name="M:C5.ArrayList`1.#ctor(System.Int32)">
\r
4711 Create an array list with default item hasher and prescribed initial capacity.
\r
4713 <param name="capacity">The prescribed capacity</param>
\r
4715 <member name="M:C5.ArrayList`1.#ctor(System.Int32,C5.IHasher{`0})">
\r
4717 Create an array list with external item hasher and prescribed initial capacity.
\r
4719 <param name="capacity">The prescribed capacity</param>
\r
4720 <param name="hasher">The external hasher</param>
\r
4722 <member name="M:C5.ArrayList`1.Insert(System.Int32,`0)">
\r
4724 Insert an item at a specific index location in this list.
\r
4725 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
4726 > the size of the collection.</summary>
\r
4727 <param name="i">The index at which to insert.</param>
\r
4728 <param name="item">The item to insert.</param>
\r
4730 <member name="M:C5.ArrayList`1.InsertAll(System.Int32,System.Collections.Generic.IEnumerable{`0})">
\r
4732 Insert into this list all items from an enumerable collection starting
\r
4733 at a particular index.
\r
4734 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
4735 > the size of the collection.
\r
4737 <param name="i">Index to start inserting at</param>
\r
4738 <param name="items">Items to insert</param>
\r
4740 <member name="M:C5.ArrayList`1.InsertBefore(`0,`0)">
\r
4742 Insert an item right before the first occurrence of some target item.
\r
4743 <exception cref="T:System.ArgumentException"/> if target is not found.
\r
4745 <param name="item">The item to insert.</param>
\r
4746 <param name="target">The target before which to insert.</param>
\r
4748 <member name="M:C5.ArrayList`1.InsertAfter(`0,`0)">
\r
4750 Insert an item right after the last(???) occurrence of some target item.
\r
4751 <exception cref="T:System.ArgumentException"/> if target is not found.
\r
4753 <param name="item">The item to insert.</param>
\r
4754 <param name="target">The target after which to insert.</param>
\r
4756 <member name="M:C5.ArrayList`1.InsertFirst(`0)">
\r
4758 Insert an item at the front of this list;
\r
4760 <param name="item">The item to insert.</param>
\r
4762 <member name="M:C5.ArrayList`1.InsertLast(`0)">
\r
4764 Insert an item at the back of this list.
\r
4766 <param name="item">The item to insert.</param>
\r
4768 <member name="M:C5.ArrayList`1.FindAll(C5.Filter{`0})">
\r
4770 Create a new list consisting of the items of this list satisfying a
\r
4771 certain predicate.
\r
4773 <param name="filter">The filter delegate defining the predicate.</param>
\r
4774 <returns>The new list.</returns>
\r
4776 <member name="M:C5.ArrayList`1.Map``1(C5.Mapper{`0,``0})">
\r
4778 Create a new list consisting of the results of mapping all items of this
\r
4779 list. The new list will use the default hasher for the item type V.
\r
4781 <typeparam name="V">The type of items of the new list</typeparam>
\r
4782 <param name="mapper">The delegate defining the map.</param>
\r
4783 <returns>The new list.</returns>
\r
4785 <member name="M:C5.ArrayList`1.Map``1(C5.Mapper{`0,``0},C5.IHasher{``0})">
\r
4787 Create a new list consisting of the results of mapping all items of this
\r
4788 list. The new list will use a specified hasher for the item type.
\r
4790 <typeparam name="V">The type of items of the new list</typeparam>
\r
4791 <param name="mapper">The delegate defining the map.</param>
\r
4792 <param name="hasher">The hasher to use for the new list</param>
\r
4793 <returns>The new list.</returns>
\r
4795 <member name="M:C5.ArrayList`1.Remove">
\r
4797 Remove one item from the list: from the front if <code>FIFO</code>
\r
4798 is true, else from the back.
\r
4799 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
4801 <returns>The removed item.</returns>
\r
4803 <member name="M:C5.ArrayList`1.RemoveFirst">
\r
4805 Remove one item from the fromnt of the list.
\r
4806 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
4808 <returns>The removed item.</returns>
\r
4810 <member name="M:C5.ArrayList`1.RemoveLast">
\r
4812 Remove one item from the back of the list.
\r
4814 <exception cref="T:System.InvalidOperationException"> if this list is empty.</exception>
\r
4815 <returns>The removed item.</returns>
\r
4817 <member name="M:C5.ArrayList`1.View(System.Int32,System.Int32)">
\r
4819 Create a list view on this list.
\r
4820 <exception cref="T:System.ArgumentOutOfRangeException"/> if the start or count is negative
\r
4821 <exception cref="T:System.ArgumentException"/> if the range does not fit within list.
\r
4823 <param name="start">The index in this list of the start of the view.</param>
\r
4824 <param name="count">The size of the view.</param>
\r
4825 <returns>The new list view.</returns>
\r
4827 <member name="M:C5.ArrayList`1.Slide(System.Int32)">
\r
4829 Slide this list view along the underlying list.
\r
4830 <exception cref="T:System.InvalidOperationException"/> if this list is not a view.
\r
4831 <exception cref="T:System.ArgumentOutOfRangeException"/> if the operation
\r
4832 would bring either end of the view outside the underlying list.
\r
4834 <param name="offset">The signed amount to slide: positive to slide
\r
4835 towards the end.</param>
\r
4837 <member name="M:C5.ArrayList`1.Slide(System.Int32,System.Int32)">
\r
4839 Slide this list view along the underlying list, changing its size.
\r
4840 <exception cref="T:System.InvalidOperationException"/> if this list is not a view.
\r
4841 <exception cref="T:System.ArgumentOutOfRangeException"/> if the operation
\r
4842 would bring either end of the view outside the underlying list.
\r
4844 <param name="offset">The signed amount to slide: positive to slide
\r
4845 towards the end.</param>
\r
4846 <param name="size">The new size of the view.</param>
\r
4848 <member name="M:C5.ArrayList`1.Reverse">
\r
4850 Reverst the list so the items are in the opposite sequence order.
\r
4853 <member name="M:C5.ArrayList`1.Reverse(System.Int32,System.Int32)">
\r
4855 Reverst part of the list so the items are in the opposite sequence order.
\r
4856 <exception cref="T:System.ArgumentException"/> if the count is negative.
\r
4857 <exception cref="T:System.ArgumentOutOfRangeException"/> if the part does not fit
\r
4860 <param name="start">The index of the start of the part to reverse.</param>
\r
4861 <param name="count">The size of the part to reverse.</param>
\r
4863 <member name="M:C5.ArrayList`1.IsSorted(C5.IComparer{`0})">
\r
4865 Check if this list is sorted according to a specific sorting order.
\r
4867 <param name="c">The comparer defining the sorting order.</param>
\r
4868 <returns>True if the list is sorted, else false.</returns>
\r
4870 <member name="M:C5.ArrayList`1.Sort(C5.IComparer{`0})">
\r
4872 Sort the items of the list according to a specific sorting order.
\r
4874 <param name="c">The comparer defining the sorting order.</param>
\r
4876 <member name="M:C5.ArrayList`1.Shuffle">
\r
4878 Randonmly shuffle the items of this list.
\r
4881 <member name="M:C5.ArrayList`1.Shuffle(System.Random)">
\r
4883 Shuffle the items of this list according to a specific random source.
\r
4885 <param name="rnd">The random source.</param>
\r
4887 <member name="M:C5.ArrayList`1.IndexOf(`0)">
\r
4889 Search for an item in the list going forwrds from the start.
\r
4891 <param name="item">Item to search for.</param>
\r
4892 <returns>Index of item from start.</returns>
\r
4894 <member name="M:C5.ArrayList`1.LastIndexOf(`0)">
\r
4896 Search for an item in the list going backwords from the end.
\r
4898 <param name="item">Item to search for.</param>
\r
4899 <returns>Index of of item from the end.</returns>
\r
4901 <member name="M:C5.ArrayList`1.RemoveAt(System.Int32)">
\r
4903 Remove the item at a specific position of the list.
\r
4904 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
4905 >= the size of the collection.
\r
4907 <param name="i">The index of the item to remove.</param>
\r
4908 <returns>The removed item.</returns>
\r
4910 <member name="M:C5.ArrayList`1.RemoveInterval(System.Int32,System.Int32)">
\r
4912 Remove all items in an index interval.
\r
4913 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
4915 <param name="start">The index of the first item to remove.</param>
\r
4916 <param name="count">The number of items to remove.</param>
\r
4918 <member name="M:C5.ArrayList`1.Contains(`0)">
\r
4920 Check if this collection contains (an item equivalent to according to the
\r
4921 itemhasher) a particular value.
\r
4923 <param name="item">The value to check for.</param>
\r
4924 <returns>True if the items is in this collection.</returns>
\r
4926 <member name="M:C5.ArrayList`1.Find(`0@)">
\r
4928 Check if this collection contains an item equivalent according to the
\r
4929 itemhasher to a particular value. If so, return in the ref argument (a
\r
4930 binary copy of) the actual value found.
\r
4932 <param name="item">The value to look for.</param>
\r
4933 <returns>True if the items is in this collection.</returns>
\r
4935 <member name="M:C5.ArrayList`1.Update(`0)">
\r
4937 Check if this collection contains an item equivalent according to the
\r
4938 itemhasher to a particular value. If so, update the item in the collection
\r
4939 to with a binary copy of the supplied value. This will only update the first
\r
4942 <param name="item">Value to update.</param>
\r
4943 <returns>True if the item was found and hence updated.</returns>
\r
4945 <member name="M:C5.ArrayList`1.FindOrAdd(`0@)">
\r
4947 Check if this collection contains an item equivalent according to the
\r
4948 itemhasher to a particular value. If so, return in the ref argument (a
\r
4949 binary copy of) the actual value found. Else, add the item to the collection.
\r
4951 <param name="item">The value to look for.</param>
\r
4952 <returns>True if the item was found (hence not added).</returns>
\r
4954 <member name="M:C5.ArrayList`1.UpdateOrAdd(`0)">
\r
4956 Check if this collection contains an item equivalent according to the
\r
4957 itemhasher to a particular value. If so, update the item in the collection
\r
4958 to with a binary copy of the supplied value. This will only update the first
\r
4961 <param name="item">Value to update.</param>
\r
4962 <returns>True if the item was found and hence updated.</returns>
\r
4964 <member name="M:C5.ArrayList`1.Remove(`0)">
\r
4966 Remove the first copy of a particular item from this collection.
\r
4968 <param name="item">The value to remove.</param>
\r
4969 <returns>True if the item was found (and removed).</returns>
\r
4971 <member name="M:C5.ArrayList`1.RemoveWithReturn(`0@)">
\r
4973 Remove the first copy of a particular item from this collection if found.
\r
4974 If an item was removed, report a binary copy of the actual item removed in
\r
4977 <param name="item">The value to remove on input.</param>
\r
4978 <returns>True if the item was found (and removed).</returns>
\r
4980 <member name="M:C5.ArrayList`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
4982 Remove all items in another collection from this one, taking multiplicities into account.
\r
4983 Matching items will be removed from the front. Current implementation is not optimal.
\r
4985 <param name="items">The items to remove.</param>
\r
4987 <member name="M:C5.ArrayList`1.Clear">
\r
4989 Remove all items from this collection, resetting internal array size.
\r
4992 <member name="M:C5.ArrayList`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
4994 Remove all items not in some other collection from this one, taking multiplicities into account.
\r
4995 Items are retained front first. Current implementation is not optimal.
\r
4997 <param name="items">The items to retain.</param>
\r
4999 <member name="M:C5.ArrayList`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
5001 Check if this collection contains all the values in another collection,
\r
5002 taking multiplicities into account.
\r
5003 Current implementation is not optimal.
\r
5005 <param name="items">The </param>
\r
5006 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
5008 <member name="M:C5.ArrayList`1.ContainsCount(`0)">
\r
5010 Count the number of items of the collection equal to a particular value.
\r
5011 Returns 0 if and only if the value is not in the collection.
\r
5013 <param name="item">The value to count.</param>
\r
5014 <returns>The number of copies found.</returns>
\r
5016 <member name="M:C5.ArrayList`1.RemoveAllCopies(`0)">
\r
5018 Remove all items equal to a given one.
\r
5020 <param name="item">The value to remove.</param>
\r
5022 <member name="M:C5.ArrayList`1.Check">
\r
5024 Check the integrity of the internal data structures of this array list.
\r
5026 <returns>True if check does not fail.</returns>
\r
5028 <member name="M:C5.ArrayList`1.Add(`0)">
\r
5030 Add an item to end of this list.
\r
5032 <param name="item">The item to add.</param>
\r
5033 <returns>True</returns>
\r
5035 <member name="M:C5.ArrayList`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
5037 Add the elements from another collection to this collection.
\r
5039 <param name="items">The items to add.</param>
\r
5041 <member name="M:C5.ArrayList`1.C5#IDirectedEnumerable{T}#Backwards">
\r
5043 Create a collection containing the same items as this collection, but
\r
5044 whose enumerator will enumerate the items backwards. The new collection
\r
5045 will become invalid if the original is modified. Method typicaly used as in
\r
5046 <code>foreach (T x in coll.Backwards()) {...}</code>
\r
5048 <returns>The backwards collection.</returns>
\r
5050 <member name="M:C5.ArrayList`1.Push(`0)">
\r
5052 Push an item to the top of the stack.
\r
5054 <param name="item">The item</param>
\r
5056 <member name="M:C5.ArrayList`1.Pop">
\r
5058 Pop the item at the top of the stack from the stack.
\r
5060 <returns>The popped item.</returns>
\r
5062 <member name="M:C5.ArrayList`1.EnQueue(`0)">
\r
5064 Enqueue an item at the back of the queue.
\r
5066 <param name="item">The item</param>
\r
5068 <member name="M:C5.ArrayList`1.DeQueue">
\r
5070 Dequeue an item from the front of the queue.
\r
5072 <returns>The item</returns>
\r
5074 <member name="P:C5.ArrayList`1.First">
\r
5076 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
5078 <value>The first item in this list.</value>
\r
5080 <member name="P:C5.ArrayList`1.Last">
\r
5082 <exception cref="T:System.InvalidOperationException"/> if this list is empty.
\r
5084 <value>The last item in this list.</value>
\r
5086 <member name="P:C5.ArrayList`1.FIFO">
\r
5088 Since <code>Add(T item)</code> always add at the end of the list,
\r
5089 this describes if list has FIFO or LIFO semantics.
\r
5091 <value>True if the <code>Remove()</code> operation removes from the
\r
5092 start of the list, false if it removes from the end.</value>
\r
5094 <member name="P:C5.ArrayList`1.Item(System.Int32)">
\r
5096 On this list, this indexer is read/write.
\r
5097 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
5098 >= the size of the collection.
\r
5100 <value>The i'th item of this list.</value>
\r
5101 <param name="i">The index of the item to fetch or store.</param>
\r
5103 <member name="P:C5.ArrayList`1.Underlying">
\r
5105 Null if this list is not a view.
\r
5107 <value>Underlying list for view.</value>
\r
5109 <member name="P:C5.ArrayList`1.Offset">
\r
5112 <value>Offset for this list view or 0 for an underlying list.</value>
\r
5114 <member name="P:C5.ArrayList`1.ContainsSpeed">
\r
5116 The value is symbolic indicating the type of asymptotic complexity
\r
5117 in terms of the size of this collection (worst-case or amortized as
\r
5120 <value>Speed.Linear</value>
\r
5122 <member name="P:C5.ArrayList`1.AllowsDuplicates">
\r
5126 <value>True, indicating array list has bag semantics.</value>
\r
5128 <member name="T:C5.ComparerBuilder.FromComparable`1">
\r
5130 A default item comparer for an item type that is either generic (IComparable<T>)
\r
5131 or ordinarily (System.IComparable) comparable.
\r
5134 <member name="M:C5.ComparerBuilder.FromComparable`1.Examine">
\r
5136 Create a default comparer
\r
5137 <exception cref="T:System.ArgumentException"/> if T is not comparable.
\r
5139 <returns>The comparer</returns>
\r
5141 <member name="T:C5.HasherBuilder.SequencedHasher`2">
\r
5143 Prototype for an sequenced hasher for IIndexed[W]
\r
5144 This will use the IIndexed[W] specific operations
\r
5147 <member name="M:C5.HasherBuilder.SequencedHasher`2.GetHashCode(`0)">
\r
5149 Get the hash code with respect to this sequenced hasher
\r
5151 <param name="item">The item</param>
\r
5152 <returns>The hash code</returns>
\r
5154 <member name="M:C5.HasherBuilder.SequencedHasher`2.Equals(`0,`0)">
\r
5156 Check if two items are equal with respect to this sequenced hasher
\r
5158 <param name="i1">first item</param>
\r
5159 <param name="i2">second item</param>
\r
5160 <returns>True if equal</returns>
\r
5162 <member name="T:C5.HasherBuilder.UnsequencedHasher`2">
\r
5164 Prototype for an unsequenced hasher for ICollection[W]
\r
5165 This will use the ICollection[W] specific operations
\r
5168 <member name="M:C5.HasherBuilder.UnsequencedHasher`2.GetHashCode(`0)">
\r
5170 Get the hash code with respect to this unsequenced hasher
\r
5172 <param name="item">The item</param>
\r
5173 <returns>The hash code</returns>
\r
5175 <member name="M:C5.HasherBuilder.UnsequencedHasher`2.Equals(`0,`0)">
\r
5177 Check if two items are equal with respect to this unsequenced hasher
\r
5179 <param name="i1">first item</param>
\r
5180 <param name="i2">second item</param>
\r
5181 <returns>True if equal</returns>
\r
5183 <member name="T:C5.HasherBuilder.ByPrototype`1">
\r
5185 Create a hasher for T that is DefaultValueTypeHasher[T]
\r
5186 or DefaultReferenceTypeHasher[T] unless T has been
\r
5187 instatiated to a type of the exact form IIndexed[W] or ICollection[W]
\r
5188 in which case Examine will return Sequenced- repectively UnsequencedHasher.
\r
5191 <member name="M:C5.HasherBuilder.ByPrototype`1.Examine">
\r
5193 See class description
\r
5195 <returns>The hasher</returns>
\r
5197 <member name="T:C5.HasherBuilder.ByInvoke`1">
\r
5199 IHasher factory class: examines at instatiation time if T is an
\r
5200 interface implementing "int GetHashCode()" and "bool Equals(T)".
\r
5201 If those are not present, MakeHasher will return a default hasher,
\r
5202 else this class will implement Ihasher[T] via Invoke() on the
\r
5203 reflected method infos.
\r
5206 <member name="M:C5.HasherBuilder.ByInvoke`1.MakeHasher">
\r
5210 <returns></returns>
\r
5212 <member name="M:C5.HasherBuilder.ByInvoke`1.GetHashCode(`0)">
\r
5216 <param name="item"></param>
\r
5217 <returns></returns>
\r
5219 <member name="M:C5.HasherBuilder.ByInvoke`1.Equals(`0,`0)">
\r
5223 <param name="i1"></param>
\r
5224 <param name="i2"></param>
\r
5225 <returns></returns>
\r
5227 <member name="T:C5.HasherBuilder.ByRTCG">
\r
5229 Like ByInvoke, but tries to build a hasher by RTCG to
\r
5230 avoid the Invoke() overhead. Does not work as intended
\r
5231 because of a Whidbey RTCG bug.
\r
5234 <member name="M:C5.HasherBuilder.ByRTCG.CreateHasher``1(System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
\r
5238 <param name="hinfo"></param>
\r
5239 <param name="einfo"></param>
\r
5240 <returns></returns>
\r
5242 <member name="M:C5.HasherBuilder.ByRTCG.build``1">
\r
5246 <typeparam name="T"></typeparam>
\r
5247 <returns></returns>
\r
5249 <member name="M:C5.HasherBuilder.ByRTCG.dump">
\r
5254 <member name="T:C5.HashSet`1">
\r
5256 A set collection class based on linear hashing
\r
5259 <member name="M:C5.HashSet`1.#ctor">
\r
5261 Create a hash set with natural item hasher and default fill threshold (66%)
\r
5262 and initial table size (16).
\r
5265 <member name="M:C5.HashSet`1.#ctor(C5.IHasher{`0})">
\r
5267 Create a hash set with external item hasher and default fill threshold (66%)
\r
5268 and initial table size (16).
\r
5270 <param name="itemhasher">The external item hasher</param>
\r
5272 <member name="M:C5.HashSet`1.#ctor(System.Int32,C5.IHasher{`0})">
\r
5274 Create a hash set with external item hasher and default fill threshold (66%)
\r
5276 <param name="capacity">Initial table size (rounded to power of 2, at least 16)</param>
\r
5277 <param name="itemhasher">The external item hasher</param>
\r
5279 <member name="M:C5.HashSet`1.#ctor(System.Int32,System.Double,C5.IHasher{`0})">
\r
5281 Create a hash set with external item hasher.
\r
5283 <param name="capacity">Initial table size (rounded to power of 2, at least 16)</param>
\r
5284 <param name="fill">Fill threshold (in range 10% to 90%)</param>
\r
5285 <param name="itemhasher">The external item hasher</param>
\r
5287 <member name="M:C5.HashSet`1.Contains(`0)">
\r
5289 Check if an item is in the set
\r
5291 <param name="item">The item to look for</param>
\r
5292 <returns>True if set contains item</returns>
\r
5294 <member name="M:C5.HashSet`1.Find(`0@)">
\r
5296 Check if an item (collection equal to a given one) is in the set and
\r
5297 if so report the actual item object found.
\r
5299 <param name="item">On entry, the item to look for.
\r
5300 On exit the item found, if any</param>
\r
5301 <returns>True if set contains item</returns>
\r
5303 <member name="M:C5.HashSet`1.Update(`0)">
\r
5305 Check if an item (collection equal to a given one) is in the set and
\r
5306 if so replace the item object in the set with the supplied one.
\r
5308 <param name="item">The item object to update with</param>
\r
5309 <returns>True if item was found (and updated)</returns>
\r
5311 <member name="M:C5.HashSet`1.FindOrAdd(`0@)">
\r
5313 Check if an item (collection equal to a given one) is in the set.
\r
5314 If found, report the actual item object in the set,
\r
5315 else add the supplied one.
\r
5317 <param name="item">On entry, the item to look for or add.
\r
5318 On exit the actual object found, if any.</param>
\r
5319 <returns>True if item was found</returns>
\r
5321 <member name="M:C5.HashSet`1.UpdateOrAdd(`0)">
\r
5323 Check if an item (collection equal to a supplied one) is in the set and
\r
5324 if so replace the item object in the set with the supplied one; else
\r
5325 add the supplied one.
\r
5327 <param name="item">The item to look for and update or add</param>
\r
5328 <returns>True if item was updated</returns>
\r
5330 <member name="M:C5.HashSet`1.Remove(`0)">
\r
5332 Remove an item from the set
\r
5334 <param name="item">The item to remove</param>
\r
5335 <returns>True if item was (found and) removed </returns>
\r
5337 <member name="M:C5.HashSet`1.RemoveWithReturn(`0@)">
\r
5339 Remove an item from the set, reporting the actual matching item object.
\r
5341 <param name="item">On entry the item to remove.
\r
5342 On exit, the actual removed item object.</param>
\r
5343 <returns>True if item was found.</returns>
\r
5345 <member name="M:C5.HashSet`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
5347 Remove all items in a supplied collection from this set.
\r
5349 <param name="items">The items to remove.</param>
\r
5351 <member name="M:C5.HashSet`1.Clear">
\r
5353 Remove all items from the set, resetting internal table to initial size.
\r
5356 <member name="M:C5.HashSet`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
5358 Remove all items *not* in a supplied collection from this set.
\r
5360 <param name="items">The items to retain</param>
\r
5362 <member name="M:C5.HashSet`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
5364 Check if all items in a supplied collection is in this set
\r
5365 (ignoring multiplicities).
\r
5367 <param name="items">The items to look for.</param>
\r
5368 <returns>True if all items are found.</returns>
\r
5370 <member name="M:C5.HashSet`1.ToArray">
\r
5372 Create an array containing all items in this set (in enumeration order).
\r
5374 <returns>The array</returns>
\r
5376 <member name="M:C5.HashSet`1.ContainsCount(`0)">
\r
5378 Count the number of times an item is in this set (either 0 or 1).
\r
5380 <param name="item">The item to look for.</param>
\r
5381 <returns>1 if item is in set, 0 else</returns>
\r
5383 <member name="M:C5.HashSet`1.RemoveAllCopies(`0)">
\r
5385 Remove all (at most 1) copies of item from this set.
\r
5387 <param name="item">The item to remove</param>
\r
5389 <member name="M:C5.HashSet`1.GetEnumerator">
\r
5391 Create an enumerator for this set.
\r
5393 <returns>The enumerator</returns>
\r
5395 <member name="M:C5.HashSet`1.Add(`0)">
\r
5397 Add an item to this set.
\r
5399 <param name="item">The item to add.</param>
\r
5400 <returns>True if item was added (i.e. not found)</returns>
\r
5402 <member name="M:C5.HashSet`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
5404 Add all items of a collection to this set.
\r
5406 <param name="items">The items to add</param>
\r
5408 <member name="M:C5.HashSet`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
5410 Add the elements from another collection with a more specialized item type
\r
5411 to this collection. Since this
\r
5412 collection has set semantics, only items not already in the collection
\r
5415 <typeparam name="U">The type of items to add</typeparam>
\r
5416 <param name="items">The items to add</param>
\r
5418 <member name="M:C5.HashSet`1.Check">
\r
5420 Test internal structure of data (invariants)
\r
5422 <returns>True if pass</returns>
\r
5424 <member name="M:C5.HashSet`1.BucketSizeDistribution">
\r
5426 Produce statistics on distribution of bucket sizes. Current implementation is incomplete.
\r
5428 <returns>Histogram data.</returns>
\r
5430 <member name="P:C5.HashSet`1.Features">
\r
5432 Show which implementation features was chosen at compilation time
\r
5435 <member name="P:C5.HashSet`1.ContainsSpeed">
\r
5437 The complexity of the Contains operation
\r
5439 <value>Always returns Speed.Constant</value>
\r
5441 <member name="P:C5.HashSet`1.AllowsDuplicates">
\r
5443 Report if this is a set collection.
\r
5445 <value>Always false</value>
\r
5447 <member name="T:C5.HashSet`1.Feature">
\r
5449 Enum class to assist printing of compilation alternatives.
\r
5452 <member name="F:C5.HashSet`1.Feature.Dummy">
\r
5457 <member name="F:C5.HashSet`1.Feature.RefTypeBucket">
\r
5459 Buckets are of reference type
\r
5462 <member name="F:C5.HashSet`1.Feature.ValueTypeBucket">
\r
5464 Primary buckets are of value type
\r
5467 <member name="F:C5.HashSet`1.Feature.LinearProbing">
\r
5469 Using linear probing to resolve index clashes
\r
5472 <member name="F:C5.HashSet`1.Feature.ShrinkTable">
\r
5474 Shrink table when very sparsely filled
\r
5477 <member name="F:C5.HashSet`1.Feature.Chaining">
\r
5479 Use chaining to resolve index clashes
\r
5482 <member name="F:C5.HashSet`1.Feature.InterHasher">
\r
5484 Use hash function on item hash code
\r
5487 <member name="F:C5.HashSet`1.Feature.RandomInterHasher">
\r
5489 Use a universal family of hash functions on item hash code
\r
5492 <member name="T:C5.GuardedEnumerator`1">
\r
5494 A read-only wrapper class for a generic enumerator
\r
5497 <member name="M:C5.GuardedEnumerator`1.#ctor(System.Collections.Generic.IEnumerator{`0})">
\r
5499 Create a wrapper around a generic enumerator
\r
5501 <param name="enumerator">The enumerator to wrap</param>
\r
5503 <member name="M:C5.GuardedEnumerator`1.MoveNext">
\r
5505 Move wrapped enumerator to next item, or the first item if
\r
5506 this is the first call to MoveNext.
\r
5508 <returns>True if enumerator is valid now</returns>
\r
5510 <member name="M:C5.GuardedEnumerator`1.Dispose">
\r
5512 Dispose wrapped enumerator
\r
5515 <member name="P:C5.GuardedEnumerator`1.Current">
\r
5517 Undefined if enumerator is not valid (MoveNext hash been called returning true)
\r
5519 <value>The current item of the wrapped enumerator.</value>
\r
5521 <member name="T:C5.GuardedEnumerable`1">
\r
5523 A read-only wrapper class for a generic enumerable
\r
5525 <p>This is mainly interesting as a base of other guard classes</p>
\r
5528 <member name="M:C5.GuardedEnumerable`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
\r
5530 Wrap an enumerable in a read-only wrapper
\r
5532 <param name="enumerable">The enumerable to wrap</param>
\r
5534 <member name="M:C5.GuardedEnumerable`1.GetEnumerator">
\r
5536 Get an enumerator from the wrapped enumerable
\r
5538 <returns>The enumerator (itself wrapped)</returns>
\r
5540 <member name="T:C5.GuardedDirectedEnumerable`1">
\r
5542 A read-only wrapper for a generic directed enumerable
\r
5544 <p>This is mainly interesting as a base of other guard classes</p>
\r
5547 <member name="M:C5.GuardedDirectedEnumerable`1.#ctor(C5.IDirectedEnumerable{`0})">
\r
5549 Wrap a directed enumerable in a read-only wrapper
\r
5551 <param name="directedenumerable">the collection to wrap</param>
\r
5553 <member name="M:C5.GuardedDirectedEnumerable`1.Backwards">
\r
5555 Get a enumerable that enumerates the wrapped collection in the opposite direction
\r
5557 <returns>The mirrored enumerable</returns>
\r
5559 <member name="P:C5.GuardedDirectedEnumerable`1.Direction">
\r
5561 <code>Forwards</code> if same, else <code>Backwards</code>
\r
5563 <value>The enumeration direction relative to the original collection.</value>
\r
5565 <member name="T:C5.GuardedCollectionValue`1">
\r
5567 A read-only wrapper for an ICollectionValue<T>
\r
5569 <p>This is mainly interesting as a base of other guard classes</p>
\r
5572 <member name="M:C5.GuardedCollectionValue`1.#ctor(C5.ICollectionValue{`0})">
\r
5574 Wrap a ICollectionValue<T> in a read-only wrapper
\r
5576 <param name="collection">the collection to wrap</param>
\r
5578 <member name="M:C5.GuardedCollectionValue`1.CopyTo(`0[],System.Int32)">
\r
5580 Copy the items of the wrapped collection to an array
\r
5582 <param name="a">The array</param>
\r
5583 <param name="i">Starting offset</param>
\r
5585 <member name="M:C5.GuardedCollectionValue`1.ToArray">
\r
5587 Create an array from the items of the wrapped collection
\r
5589 <returns>The array</returns>
\r
5591 <member name="M:C5.GuardedCollectionValue`1.Apply(C5.Applier{`0})">
\r
5593 Apply a delegate to all items of the wrapped enumerable.
\r
5595 <param name="a">The delegate to apply</param>
\r
5597 <member name="M:C5.GuardedCollectionValue`1.Exists(C5.Filter{`0})">
\r
5599 Check if there exists an item that satisfies a
\r
5600 specific predicate in the wrapped enumerable.
\r
5602 <param name="filter">A filter delegate
\r
5603 (<see cref="T:C5.Filter!1"/>) defining the predicate</param>
\r
5604 <returns>True is such an item exists</returns>
\r
5606 <member name="M:C5.GuardedCollectionValue`1.All(C5.Filter{`0})">
\r
5608 Check if all items in the wrapped enumerable satisfies a specific predicate.
\r
5610 <param name="filter">A filter delegate
\r
5611 (<see cref="T:C5.Filter!1"/>) defining the predicate</param>
\r
5612 <returns>True if all items satisfies the predicate</returns>
\r
5614 <member name="P:C5.GuardedCollectionValue`1.Count">
\r
5616 Get the size of the wrapped collection
\r
5618 <value>The size</value>
\r
5620 <member name="P:C5.GuardedCollectionValue`1.CountSpeed">
\r
5622 The value is symbolic indicating the type of asymptotic complexity
\r
5623 in terms of the size of this collection (worst-case or amortized as
\r
5626 <value>A characterization of the speed of the
\r
5627 <code>Count</code> property in this collection.</value>
\r
5629 <member name="T:C5.GuardedDirectedCollectionValue`1">
\r
5631 A read-only wrapper for a directed collection
\r
5633 <p>This is mainly interesting as a base of other guard classes</p>
\r
5636 <member name="M:C5.GuardedDirectedCollectionValue`1.#ctor(C5.IDirectedCollectionValue{`0})">
\r
5638 Wrap a directed collection in a read-only wrapper
\r
5640 <param name="directedcollection">the collection to wrap</param>
\r
5642 <member name="M:C5.GuardedDirectedCollectionValue`1.Backwards">
\r
5644 Get a collection that enumerates the wrapped collection in the opposite direction
\r
5646 <returns>The mirrored collection</returns>
\r
5648 <member name="P:C5.GuardedDirectedCollectionValue`1.Direction">
\r
5650 <code>Forwards</code> if same, else <code>Backwards</code>
\r
5652 <value>The enumeration direction relative to the original collection.</value>
\r
5654 <member name="T:C5.GuardedCollection`1">
\r
5656 A read-only wrapper for an ICollection<T>.
\r
5657 <see cref="T:C5.ICollection!1"/>
\r
5659 <p>Suitable for wrapping hash tables, <see cref="T:C5.HashSet!1"/>
\r
5660 and <see cref="T:C5.HashBag!1"/> </p>
\r
5663 <member name="M:C5.GuardedCollection`1.#ctor(C5.ICollection{`0})">
\r
5665 Wrap an ICollection<T> in a read-only wrapper
\r
5667 <param name="collection">the collection to wrap</param>
\r
5669 <member name="M:C5.GuardedCollection`1.Contains(`0)">
\r
5671 Check if an item is in the wrapped collection
\r
5673 <param name="item">The item</param>
\r
5674 <returns>True if found</returns>
\r
5676 <member name="M:C5.GuardedCollection`1.ContainsCount(`0)">
\r
5678 Count the number of times an item appears in the wrapped collection
\r
5680 <param name="item">The item</param>
\r
5681 <returns>The number of copies</returns>
\r
5683 <member name="M:C5.GuardedCollection`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
5685 Check if all items in the argument is in the wrapped collection
\r
5687 <param name="items">The items</param>
\r
5688 <returns>True if so</returns>
\r
5690 <member name="M:C5.GuardedCollection`1.Find(`0@)">
\r
5692 Search for an item in the wrapped collection
\r
5694 <param name="item">On entry the item to look for, on exit the equivalent item found (if any)</param>
\r
5695 <returns></returns>
\r
5697 <member name="M:C5.GuardedCollection`1.FindOrAdd(`0@)">
\r
5699 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5701 <param name="item"></param>
\r
5702 <returns></returns>
\r
5704 <member name="M:C5.GuardedCollection`1.Update(`0)">
\r
5706 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5708 <param name="item"></param>
\r
5709 <returns></returns>
\r
5711 <member name="M:C5.GuardedCollection`1.UpdateOrAdd(`0)">
\r
5713 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5715 <param name="item"></param>
\r
5716 <returns></returns>
\r
5718 <member name="M:C5.GuardedCollection`1.Remove(`0)">
\r
5720 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5722 <param name="item"></param>
\r
5723 <returns></returns>
\r
5725 <member name="M:C5.GuardedCollection`1.RemoveWithReturn(`0@)">
\r
5727 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5729 <param name="item"></param>
\r
5730 <returns></returns>
\r
5732 <member name="M:C5.GuardedCollection`1.RemoveAllCopies(`0)">
\r
5734 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5736 <param name="item"></param>
\r
5738 <member name="M:C5.GuardedCollection`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
5740 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5742 <param name="items"></param>
\r
5744 <member name="M:C5.GuardedCollection`1.Clear">
\r
5746 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5749 <member name="M:C5.GuardedCollection`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
5751 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5753 <param name="items"></param>
\r
5755 <member name="M:C5.GuardedCollection`1.Check">
\r
5757 Check wrapped collection for internal consistency
\r
5759 <returns>True if check passed</returns>
\r
5761 <member name="M:C5.GuardedCollection`1.Add(`0)">
\r
5763 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5765 <param name="item"></param>
\r
5766 <returns></returns>
\r
5768 <member name="M:C5.GuardedCollection`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
5770 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5772 <param name="items"></param>
\r
5774 <member name="M:C5.GuardedCollection`1.C5#IExtensible{T}#AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
5776 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5778 <param name="items"></param>
\r
5780 <member name="P:C5.GuardedCollection`1.IsReadOnly">
\r
5782 (This is a read-only wrapper)
\r
5784 <value>True</value>
\r
5786 <member name="P:C5.GuardedCollection`1.ContainsSpeed">
\r
5787 <summary> </summary>
\r
5788 <value>Speed of wrapped collection</value>
\r
5790 <member name="P:C5.GuardedCollection`1.AllowsDuplicates">
\r
5791 <summary> </summary>
\r
5792 <value>False if wrapped collection has set semantics</value>
\r
5794 <member name="P:C5.GuardedCollection`1.SyncRoot">
\r
5795 <summary> </summary>
\r
5796 <value>The sync root of the wrapped collection</value>
\r
5798 <member name="P:C5.GuardedCollection`1.IsEmpty">
\r
5799 <summary> </summary>
\r
5800 <value>True if wrapped collection is empty</value>
\r
5802 <member name="T:C5.GuardedSequenced`1">
\r
5804 A read-only wrapper for a sequenced collection
\r
5806 <p>This is mainly interesting as a base of other guard classes</p>
\r
5809 <member name="M:C5.GuardedSequenced`1.#ctor(C5.ISequenced{`0})">
\r
5811 Wrap a sequenced collection in a read-only wrapper
\r
5813 <param name="sorted"></param>
\r
5815 <member name="M:C5.GuardedSequenced`1.Backwards">
\r
5817 Get a collection that enumerates the wrapped collection in the opposite direction
\r
5819 <returns>The mirrored collection</returns>
\r
5821 <member name="P:C5.GuardedSequenced`1.Direction">
\r
5823 <code>Forwards</code> if same, else <code>Backwards</code>
\r
5825 <value>The enumeration direction relative to the original collection.</value>
\r
5827 <member name="T:C5.GuardedSorted`1">
\r
5829 A read-only wrapper for a sorted collection
\r
5831 <p>This is mainly interesting as a base of other guard classes</p>
\r
5834 <member name="M:C5.GuardedSorted`1.#ctor(C5.ISorted{`0})">
\r
5836 Wrap a sorted collection in a read-only wrapper
\r
5838 <param name="sorted"></param>
\r
5840 <member name="M:C5.GuardedSorted`1.Predecessor(`0)">
\r
5842 Find the predecessor of the item in the wrapped sorted collection
\r
5844 <param name="item">The item</param>
\r
5845 <returns>The predecessor</returns>
\r
5847 <member name="M:C5.GuardedSorted`1.Successor(`0)">
\r
5849 Find the Successor of the item in the wrapped sorted collection
\r
5851 <param name="item">The item</param>
\r
5852 <returns>The Successor</returns>
\r
5854 <member name="M:C5.GuardedSorted`1.WeakPredecessor(`0)">
\r
5856 Find the weak predecessor of the item in the wrapped sorted collection
\r
5858 <param name="item">The item</param>
\r
5859 <returns>The weak predecessor</returns>
\r
5861 <member name="M:C5.GuardedSorted`1.WeakSuccessor(`0)">
\r
5863 Find the weak Successor of the item in the wrapped sorted collection
\r
5865 <param name="item">The item</param>
\r
5866 <returns>The weak Successor</returns>
\r
5868 <member name="M:C5.GuardedSorted`1.Cut(System.IComparable{`0},`0@,System.Boolean@,`0@,System.Boolean@)">
\r
5870 Run Cut on the wrapped sorted collection
\r
5872 <param name="c"></param>
\r
5873 <param name="low"></param>
\r
5874 <param name="lval"></param>
\r
5875 <param name="high"></param>
\r
5876 <param name="hval"></param>
\r
5877 <returns></returns>
\r
5879 <member name="M:C5.GuardedSorted`1.RangeFrom(`0)">
\r
5881 Get the specified range from the wrapped collection.
\r
5882 (The current implementation erroneously does not wrap the result.)
\r
5884 <param name="bot"></param>
\r
5885 <returns></returns>
\r
5887 <member name="M:C5.GuardedSorted`1.RangeFromTo(`0,`0)">
\r
5889 Get the specified range from the wrapped collection.
\r
5890 (The current implementation erroneously does not wrap the result.)
\r
5892 <param name="bot"></param>
\r
5893 <param name="top"></param>
\r
5894 <returns></returns>
\r
5896 <member name="M:C5.GuardedSorted`1.RangeTo(`0)">
\r
5898 Get the specified range from the wrapped collection.
\r
5899 (The current implementation erroneously does not wrap the result.)
\r
5901 <param name="top"></param>
\r
5902 <returns></returns>
\r
5904 <member name="M:C5.GuardedSorted`1.RangeAll">
\r
5906 Get the specified range from the wrapped collection.
\r
5907 (The current implementation erroneously does not wrap the result.)
\r
5909 <returns></returns>
\r
5911 <member name="M:C5.GuardedSorted`1.AddSorted(System.Collections.Generic.IEnumerable{`0})">
\r
5913 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5915 <param name="items"></param>
\r
5917 <member name="M:C5.GuardedSorted`1.RemoveRangeFrom(`0)">
\r
5919 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5921 <param name="low"></param>
\r
5923 <member name="M:C5.GuardedSorted`1.RemoveRangeFromTo(`0,`0)">
\r
5925 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5927 <param name="low"></param>
\r
5928 <param name="hi"></param>
\r
5930 <member name="M:C5.GuardedSorted`1.RemoveRangeTo(`0)">
\r
5932 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5934 <param name="hi"></param>
\r
5936 <member name="M:C5.GuardedSorted`1.FindMin">
\r
5938 Find the minimum of the wrapped collection
\r
5940 <returns>The minimum</returns>
\r
5942 <member name="M:C5.GuardedSorted`1.DeleteMin">
\r
5944 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5946 <returns></returns>
\r
5948 <member name="M:C5.GuardedSorted`1.FindMax">
\r
5950 Find the maximum of the wrapped collection
\r
5952 <returns>The maximum</returns>
\r
5954 <member name="M:C5.GuardedSorted`1.DeleteMax">
\r
5956 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
5958 <returns></returns>
\r
5960 <member name="P:C5.GuardedSorted`1.Comparer">
\r
5962 The comparer object supplied at creation time for the underlying collection
\r
5964 <value>The comparer</value>
\r
5966 <member name="T:C5.GuardedIndexedSorted`1">
\r
5968 Read-only wrapper for indexed sorted collections
\r
5970 <p>Suitable for wrapping TreeSet, TreeBag and SortedArray</p>
\r
5973 <member name="M:C5.GuardedIndexedSorted`1.#ctor(C5.IIndexedSorted{`0})">
\r
5975 Wrap an indexed sorted collection in a read-only wrapper
\r
5977 <param name="list">the indexed sorted collection</param>
\r
5979 <member name="M:C5.GuardedIndexedSorted`1.RangeFrom(`0)">
\r
5981 Get the specified range from the wrapped collection.
\r
5982 (The current implementation erroneously does not wrap the result.)
\r
5984 <param name="bot"></param>
\r
5985 <returns></returns>
\r
5987 <member name="M:C5.GuardedIndexedSorted`1.RangeFromTo(`0,`0)">
\r
5989 Get the specified range from the wrapped collection.
\r
5990 (The current implementation erroneously does not wrap the result.)
\r
5992 <param name="bot"></param>
\r
5993 <param name="top"></param>
\r
5994 <returns></returns>
\r
5996 <member name="M:C5.GuardedIndexedSorted`1.RangeTo(`0)">
\r
5998 Get the specified range from the wrapped collection.
\r
5999 (The current implementation erroneously does not wrap the result.)
\r
6001 <param name="top"></param>
\r
6002 <returns></returns>
\r
6004 <member name="M:C5.GuardedIndexedSorted`1.CountFrom(`0)">
\r
6006 Report the number of items in the specified range of the wrapped collection
\r
6008 <param name="bot"></param>
\r
6009 <returns></returns>
\r
6011 <member name="M:C5.GuardedIndexedSorted`1.CountFromTo(`0,`0)">
\r
6013 Report the number of items in the specified range of the wrapped collection
\r
6015 <param name="bot"></param>
\r
6016 <param name="top"></param>
\r
6017 <returns></returns>
\r
6019 <member name="M:C5.GuardedIndexedSorted`1.CountTo(`0)">
\r
6021 Report the number of items in the specified range of the wrapped collection
\r
6023 <param name="top"></param>
\r
6024 <returns></returns>
\r
6026 <member name="M:C5.GuardedIndexedSorted`1.FindAll(C5.Filter{`0})">
\r
6028 Run FindAll on the wrapped collection with the indicated filter.
\r
6029 The result will <b>not</b> be read-only.
\r
6031 <param name="f"></param>
\r
6032 <returns></returns>
\r
6034 <member name="M:C5.GuardedIndexedSorted`1.Map``1(C5.Mapper{`0,``0},C5.IComparer{``0})">
\r
6036 Run Map on the wrapped collection with the indicated mapper.
\r
6037 The result will <b>not</b> be read-only.
\r
6039 <param name="m"></param>
\r
6040 <param name="c">The comparer to use in the result</param>
\r
6041 <returns></returns>
\r
6043 <member name="M:C5.GuardedIndexedSorted`1.IndexOf(`0)">
\r
6045 Find the (first) index of an item in the wrapped collection
\r
6047 <param name="item"></param>
\r
6048 <returns></returns>
\r
6050 <member name="M:C5.GuardedIndexedSorted`1.LastIndexOf(`0)">
\r
6052 Find the last index of an item in the wrapped collection
\r
6054 <param name="item"></param>
\r
6055 <returns></returns>
\r
6057 <member name="M:C5.GuardedIndexedSorted`1.RemoveAt(System.Int32)">
\r
6059 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6061 <param name="i"></param>
\r
6062 <returns></returns>
\r
6064 <member name="M:C5.GuardedIndexedSorted`1.RemoveInterval(System.Int32,System.Int32)">
\r
6066 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6068 <param name="start"></param>
\r
6069 <param name="count"></param>
\r
6071 <member name="P:C5.GuardedIndexedSorted`1.Item(System.Int32)">
\r
6075 <value>The i'th item of the wrapped sorted collection</value>
\r
6077 <member name="P:C5.GuardedIndexedSorted`1.Item(System.Int32,System.Int32)">
\r
6078 <summary> </summary>
\r
6079 <value>A directed collection of the items in the indicated interval of the wrapped collection</value>
\r
6081 <member name="T:C5.GuardedList`1">
\r
6083 A read-only wrapper for a generic list collection
\r
6084 <p>Suitable as a wrapper for LinkedList, HashedLinkedList, ArrayList and HashedArray.
\r
6085 <see cref="T:C5.LinkedList!1"/>,
\r
6086 <see cref="T:C5.HashedLinkedList!1"/>,
\r
6087 <see cref="T:C5.ArrayList!1"/> or
\r
6088 <see cref="T:C5.HashedArray!1"/>.
\r
6092 <member name="M:C5.GuardedList`1.#ctor(C5.IList{`0})">
\r
6094 Wrap a list in a read-only wrapper
\r
6096 <param name="list">The list</param>
\r
6098 <member name="M:C5.GuardedList`1.Insert(System.Int32,`0)">
\r
6100 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6102 <param name="i"></param>
\r
6103 <param name="item"></param>
\r
6105 <member name="M:C5.GuardedList`1.InsertFirst(`0)">
\r
6107 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6109 <param name="item"></param>
\r
6111 <member name="M:C5.GuardedList`1.InsertLast(`0)">
\r
6113 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6115 <param name="item"></param>
\r
6117 <member name="M:C5.GuardedList`1.InsertBefore(`0,`0)">
\r
6119 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6121 <param name="item"></param>
\r
6122 <param name="target"></param>
\r
6124 <member name="M:C5.GuardedList`1.InsertAfter(`0,`0)">
\r
6126 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6128 <param name="item"></param>
\r
6129 <param name="target"></param>
\r
6131 <member name="M:C5.GuardedList`1.InsertAll(System.Int32,System.Collections.Generic.IEnumerable{`0})">
\r
6133 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6135 <param name="i"></param>
\r
6136 <param name="items"></param>
\r
6138 <member name="M:C5.GuardedList`1.FindAll(C5.Filter{`0})">
\r
6140 Perform FindAll on the wrapped list. The result is <b>not</b> necessarily read-only.
\r
6142 <param name="filter">The filter to use</param>
\r
6143 <returns></returns>
\r
6145 <member name="M:C5.GuardedList`1.Map``1(C5.Mapper{`0,``0})">
\r
6147 Perform Map on the wrapped list. The result is <b>not</b> necessarily read-only.
\r
6149 <typeparam name="V">The type of items of the new list</typeparam>
\r
6150 <param name="mapper">The mapper to use.</param>
\r
6151 <returns>The mapped list</returns>
\r
6153 <member name="M:C5.GuardedList`1.Map``1(C5.Mapper{`0,``0},C5.IHasher{``0})">
\r
6155 Perform Map on the wrapped list. The result is <b>not</b> necessarily read-only.
\r
6157 <typeparam name="V">The type of items of the new list</typeparam>
\r
6158 <param name="mapper">The delegate defining the map.</param>
\r
6159 <param name="hasher">The hasher to use for the new list</param>
\r
6160 <returns>The new list.</returns>
\r
6162 <member name="M:C5.GuardedList`1.Remove">
\r
6164 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6166 <returns></returns>
\r
6168 <member name="M:C5.GuardedList`1.RemoveFirst">
\r
6170 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6172 <returns></returns>
\r
6174 <member name="M:C5.GuardedList`1.RemoveLast">
\r
6176 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6178 <returns></returns>
\r
6180 <member name="M:C5.GuardedList`1.View(System.Int32,System.Int32)">
\r
6182 Create the indicated view on the wrapped list and wrap it read-only.
\r
6184 <param name="start"></param>
\r
6185 <param name="count"></param>
\r
6186 <returns></returns>
\r
6188 <member name="M:C5.GuardedList`1.Slide(System.Int32)">
\r
6190 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6192 <param name="offset"></param>
\r
6194 <member name="M:C5.GuardedList`1.Slide(System.Int32,System.Int32)">
\r
6196 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6198 <param name="offset"></param>
\r
6199 <param name="size"></param>
\r
6201 <member name="M:C5.GuardedList`1.Reverse">
\r
6203 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6206 <member name="M:C5.GuardedList`1.Reverse(System.Int32,System.Int32)">
\r
6208 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6210 <param name="start"></param>
\r
6211 <param name="count"></param>
\r
6213 <member name="M:C5.GuardedList`1.IsSorted(C5.IComparer{`0})">
\r
6215 Check if wrapped list is sorted
\r
6217 <param name="c">The sorting order to use</param>
\r
6218 <returns>True if sorted</returns>
\r
6220 <member name="M:C5.GuardedList`1.Sort(C5.IComparer{`0})">
\r
6222 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6224 <param name="c"></param>
\r
6226 <member name="M:C5.GuardedList`1.Shuffle">
\r
6228 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6231 <member name="M:C5.GuardedList`1.Shuffle(System.Random)">
\r
6233 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6235 <param name="rnd"></param>
\r
6237 <member name="M:C5.GuardedList`1.IndexOf(`0)">
\r
6239 Find the (first) index of an item in the wrapped collection
\r
6241 <param name="item"></param>
\r
6242 <returns></returns>
\r
6244 <member name="M:C5.GuardedList`1.LastIndexOf(`0)">
\r
6246 Find the last index of an item in the wrapped collection
\r
6248 <param name="item"></param>
\r
6249 <returns></returns>
\r
6251 <member name="M:C5.GuardedList`1.RemoveAt(System.Int32)">
\r
6253 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6255 <param name="i"></param>
\r
6256 <returns></returns>
\r
6258 <member name="M:C5.GuardedList`1.RemoveInterval(System.Int32,System.Int32)">
\r
6260 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6262 <param name="start"></param>
\r
6263 <param name="count"></param>
\r
6265 <member name="M:C5.GuardedList`1.Push(`0)">
\r
6269 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6270 <returns>-</returns>
\r
6272 <member name="M:C5.GuardedList`1.Pop">
\r
6276 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6277 <returns>-</returns>
\r
6279 <member name="M:C5.GuardedList`1.EnQueue(`0)">
\r
6283 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6284 <returns>-</returns>
\r
6286 <member name="M:C5.GuardedList`1.DeQueue">
\r
6290 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6291 <returns>-</returns>
\r
6293 <member name="P:C5.GuardedList`1.First">
\r
6297 <value>The first item of the wrapped list</value>
\r
6299 <member name="P:C5.GuardedList`1.Last">
\r
6303 <value>The last item of the wrapped list</value>
\r
6305 <member name="P:C5.GuardedList`1.FIFO">
\r
6307 <exception cref="T:System.InvalidOperationException"/> if used as setter
\r
6309 <value>True if wrapped list has FIFO semantics for the Add(T item) and Remove() methods</value>
\r
6311 <member name="P:C5.GuardedList`1.Item(System.Int32)">
\r
6313 <exception cref="T:System.InvalidOperationException"/> if used as setter
\r
6315 <value>The i'th item of the wrapped list</value>
\r
6317 <member name="P:C5.GuardedList`1.Underlying">
\r
6319 (This is wrong functionality)
\r
6321 <value>The wrapped underlying list of the wrapped view </value>
\r
6323 <member name="P:C5.GuardedList`1.Offset">
\r
6327 <value>The offset of the wrapped list as a view.</value>
\r
6329 <member name="P:C5.GuardedList`1.Item(System.Int32,System.Int32)">
\r
6330 <summary> </summary>
\r
6331 <value>A directed collection of the items in the indicated interval of the wrapped collection</value>
\r
6333 <member name="T:C5.GuardedDictionary`2">
\r
6335 A read-only wrapper for a dictionary.
\r
6337 <p>Suitable for wrapping a HashDictionary. <see cref="T:C5.HashDictionary!2"/></p>
\r
6340 <member name="M:C5.GuardedDictionary`2.#ctor(C5.IDictionary{`0,`1})">
\r
6342 Wrap a dictionary in a read-only wrapper
\r
6344 <param name="dict">the dictionary</param>
\r
6346 <member name="M:C5.GuardedDictionary`2.Add(`0,`1)">
\r
6348 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6350 <param name="key"></param>
\r
6351 <param name="val"></param>
\r
6353 <member name="M:C5.GuardedDictionary`2.Remove(`0)">
\r
6355 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6357 <param name="key"></param>
\r
6358 <returns></returns>
\r
6360 <member name="M:C5.GuardedDictionary`2.Remove(`0,`1@)">
\r
6362 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6364 <param name="key"></param>
\r
6365 <param name="val"></param>
\r
6366 <returns></returns>
\r
6368 <member name="M:C5.GuardedDictionary`2.Clear">
\r
6370 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6373 <member name="M:C5.GuardedDictionary`2.Contains(`0)">
\r
6375 Check if the wrapped dictionary contains a specific key
\r
6377 <param name="key">The key</param>
\r
6378 <returns>True if it does</returns>
\r
6380 <member name="M:C5.GuardedDictionary`2.Find(`0,`1@)">
\r
6382 Search for a key in the wrapped dictionary, reporting the value if found
\r
6384 <param name="key">The key</param>
\r
6385 <param name="val">On exit: the value if found</param>
\r
6386 <returns>True if found</returns>
\r
6388 <member name="M:C5.GuardedDictionary`2.Update(`0,`1)">
\r
6390 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6392 <param name="key"></param>
\r
6393 <param name="val"></param>
\r
6394 <returns></returns>
\r
6396 <member name="M:C5.GuardedDictionary`2.FindOrAdd(`0,`1@)">
\r
6398 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6400 <param name="key"></param>
\r
6401 <param name="val"></param>
\r
6402 <returns></returns>
\r
6404 <member name="M:C5.GuardedDictionary`2.UpdateOrAdd(`0,`1)">
\r
6406 <exception cref="T:System.InvalidOperationException"/> since this is a read-only wrappper
\r
6408 <param name="key"></param>
\r
6409 <param name="val"></param>
\r
6410 <returns></returns>
\r
6412 <member name="M:C5.GuardedDictionary`2.Check">
\r
6414 Check the internal consistency of the wrapped dictionary
\r
6416 <returns>True if check passed</returns>
\r
6418 <member name="P:C5.GuardedDictionary`2.Item(`0)">
\r
6420 <exception cref="T:System.InvalidOperationException"/> since this is a
\r
6421 read-only wrappper if used as a setter
\r
6423 <value>Get the value corresponding to a key in the wrapped dictionary</value>
\r
6425 <member name="P:C5.GuardedDictionary`2.Count">
\r
6426 <summary> </summary>
\r
6427 <value>The size of the wrapped dictionary</value>
\r
6429 <member name="P:C5.GuardedDictionary`2.IsReadOnly">
\r
6431 (This is a read-only wrapper)
\r
6433 <value>True</value>
\r
6435 <member name="P:C5.GuardedDictionary`2.SyncRoot">
\r
6436 <summary> </summary>
\r
6437 <value>The sync root of the wrapped dictionary</value>
\r
6439 <member name="P:C5.GuardedDictionary`2.Keys">
\r
6440 <summary> </summary>
\r
6441 <value>The collection of keys of the wrapped dictionary</value>
\r
6443 <member name="P:C5.GuardedDictionary`2.Values">
\r
6444 <summary> </summary>
\r
6445 <value>The collection of values of the wrapped dictionary</value>
\r
6447 <member name="T:C5.GuardedSortedDictionary`2">
\r
6449 A read-only wrapper for a sorted dictionary.
\r
6451 <p>Suitable for wrapping a Dictionary. <see cref="T:C5.Dictionary!2"/></p>
\r
6454 <member name="M:C5.GuardedSortedDictionary`2.#ctor(C5.ISortedDictionary{`0,`1})">
\r
6456 Wrap a sorted dictionary in a read-only wrapper
\r
6458 <param name="sorteddict">the dictionary</param>
\r
6460 <member name="M:C5.GuardedSortedDictionary`2.Predecessor(`0)">
\r
6462 Get the entry in the wrapped dictionary whose key is the
\r
6463 predecessor of a specified key.
\r
6465 <param name="key">The key</param>
\r
6466 <returns>The entry</returns>
\r
6468 <member name="M:C5.GuardedSortedDictionary`2.Successor(`0)">
\r
6470 Get the entry in the wrapped dictionary whose key is the
\r
6471 successor of a specified key.
\r
6473 <param name="key">The key</param>
\r
6474 <returns>The entry</returns>
\r
6476 <member name="M:C5.GuardedSortedDictionary`2.WeakPredecessor(`0)">
\r
6478 Get the entry in the wrapped dictionary whose key is the
\r
6479 weak predecessor of a specified key.
\r
6481 <param name="key">The key</param>
\r
6482 <returns>The entry</returns>
\r
6484 <member name="M:C5.GuardedSortedDictionary`2.WeakSuccessor(`0)">
\r
6486 Get the entry in the wrapped dictionary whose key is the
\r
6487 weak successor of a specified key.
\r
6489 <param name="key">The key</param>
\r
6490 <returns>The entry</returns>
\r
6492 <member name="T:C5.SortedArray`1">
\r
6494 A collection class implementing a sorted dynamic array data structure.
\r
6497 <member name="M:C5.SortedArray`1.binarySearch(`0,System.Int32@)">
\r
6501 <param name="item">The item to search for</param>
\r
6502 <param name="mid">The least index, mid, for which array[mid] >= item</param>
\r
6503 <returns>True if item found</returns>
\r
6505 <member name="M:C5.SortedArray`1.#ctor">
\r
6507 Create a dynamic sorted array with a natural comparer
\r
6510 <member name="M:C5.SortedArray`1.#ctor(System.Int32)">
\r
6512 Create a dynamic sorted array with a natural comparer
\r
6513 and prescribed initial capacity.
\r
6515 <param name="capacity">The capacity</param>
\r
6517 <member name="M:C5.SortedArray`1.#ctor(C5.IComparer{`0})">
\r
6519 Create a dynamic sorted array with an external comparer
\r
6521 <param name="c">The comparer</param>
\r
6523 <member name="M:C5.SortedArray`1.#ctor(System.Int32,C5.IComparer{`0})">
\r
6525 Create a dynamic sorted array with an external comparer
\r
6526 and prescribed initial capacity.
\r
6528 <param name="capacity">The capacity</param>
\r
6529 <param name="c">The comparer</param>
\r
6531 <member name="M:C5.SortedArray`1.#ctor(System.Int32,C5.IComparer{`0},C5.IHasher{`0})">
\r
6533 Create a dynamic sorted array with an external comparer, an external hasher
\r
6534 and prescribed initial capacity.
\r
6536 <param name="capacity">The capacity</param>
\r
6537 <param name="c">The comparer</param>
\r
6538 <param name="h">The hasher (compatible)</param>
\r
6540 <member name="M:C5.SortedArray`1.CountFrom(`0)">
\r
6542 Determine the number of items at or above a supplied threshold.
\r
6544 <param name="bot">The lower bound (inclusive)</param>
\r
6545 <returns>The number of matcing items.</returns>
\r
6547 <member name="M:C5.SortedArray`1.CountFromTo(`0,`0)">
\r
6549 Determine the number of items between two supplied thresholds.
\r
6551 <param name="bot">The lower bound (inclusive)</param>
\r
6552 <param name="top">The upper bound (exclusive)</param>
\r
6553 <returns>The number of matcing items.</returns>
\r
6555 <member name="M:C5.SortedArray`1.CountTo(`0)">
\r
6557 Determine the number of items below a supplied threshold.
\r
6559 <param name="top">The upper bound (exclusive)</param>
\r
6560 <returns>The number of matcing items.</returns>
\r
6562 <member name="M:C5.SortedArray`1.RangeFrom(`0)">
\r
6564 Query this sorted collection for items greater than or equal to a supplied value.
\r
6566 <param name="bot">The lower bound (inclusive).</param>
\r
6567 <returns>The result directed collection.</returns>
\r
6569 <member name="M:C5.SortedArray`1.RangeFromTo(`0,`0)">
\r
6571 Query this sorted collection for items between two supplied values.
\r
6573 <param name="bot">The lower bound (inclusive).</param>
\r
6574 <param name="top">The upper bound (exclusive).</param>
\r
6575 <returns>The result directed collection.</returns>
\r
6577 <member name="M:C5.SortedArray`1.RangeTo(`0)">
\r
6579 Query this sorted collection for items less than a supplied value.
\r
6581 <param name="top">The upper bound (exclusive).</param>
\r
6582 <returns>The result directed collection.</returns>
\r
6584 <member name="M:C5.SortedArray`1.FindAll(C5.Filter{`0})">
\r
6586 Create a new indexed sorted collection consisting of the items of this
\r
6587 indexed sorted collection satisfying a certain predicate.
\r
6589 <param name="f">The filter delegate defining the predicate.</param>
\r
6590 <returns>The new indexed sorted collection.</returns>
\r
6592 <member name="M:C5.SortedArray`1.Map``1(C5.Mapper{`0,``0},C5.IComparer{``0})">
\r
6594 Create a new indexed sorted collection consisting of the results of
\r
6595 mapping all items of this list.
\r
6596 <exception cref="T:System.ArgumentException"/> if the map is not increasing over
\r
6597 the items of this collection (with respect to the two given comparison
\r
6600 <param name="m">The delegate definging the map.</param>
\r
6601 <param name="c">The comparion relation to use for the result.</param>
\r
6602 <returns>The new sorted collection.</returns>
\r
6604 <member name="M:C5.SortedArray`1.Predecessor(`0)">
\r
6606 Find the strict predecessor in the sorted collection of a particular value,
\r
6607 i.e. the largest item in the collection less than the supplied value.
\r
6608 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
6609 supplied value is less than or equal to the minimum of this collection.)
\r
6611 <param name="item">The item to find the predecessor for.</param>
\r
6612 <returns>The predecessor.</returns>
\r
6614 <member name="M:C5.SortedArray`1.Successor(`0)">
\r
6616 Find the strict successor in the sorted collection of a particular value,
\r
6617 i.e. the least item in the collection greater than the supplied value.
\r
6618 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
6619 supplied value is greater than or equal to the maximum of this collection.)
\r
6621 <param name="item">The item to find the successor for.</param>
\r
6622 <returns>The successor.</returns>
\r
6624 <member name="M:C5.SortedArray`1.WeakPredecessor(`0)">
\r
6626 Find the weak predecessor in the sorted collection of a particular value,
\r
6627 i.e. the largest item in the collection less than or equal to the supplied value.
\r
6628 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
6629 supplied value is less than the minimum of this collection.)
\r
6631 <param name="item">The item to find the weak predecessor for.</param>
\r
6632 <returns>The weak predecessor.</returns>
\r
6634 <member name="M:C5.SortedArray`1.WeakSuccessor(`0)">
\r
6636 Find the weak successor in the sorted collection of a particular value,
\r
6637 i.e. the least item in the collection greater than or equal to the supplied value.
\r
6638 <exception cref="T:System.InvalidOperationException"/> if no such element exists (the
\r
6639 supplied value is greater than the maximum of this collection.)
\r
6641 <param name="item">The item to find the weak successor for.</param>
\r
6642 <returns>The weak successor.</returns>
\r
6644 <member name="M:C5.SortedArray`1.Cut(System.IComparable{`0},`0@,System.Boolean@,`0@,System.Boolean@)">
\r
6646 Perform a search in the sorted collection for the ranges in which a
\r
6647 non-decreasing function from the item type to <code>int</code> is
\r
6648 negative, zero respectively positive. If the supplied cut function is
\r
6649 not non-decreasing, the result of this call is undefined.
\r
6651 <param name="c">The cut function <code>T</code> to <code>int</code>, given
\r
6652 as an <code>IComparable<T></code> object, where the cut function is
\r
6653 the <code>c.CompareTo(T that)</code> method.</param>
\r
6654 <param name="low">Returns the largest item in the collection, where the
\r
6655 cut function is negative (if any).</param>
\r
6656 <param name="lowIsValid">True if the cut function is negative somewhere
\r
6657 on this collection.</param>
\r
6658 <param name="high">Returns the least item in the collection, where the
\r
6659 cut function is positive (if any).</param>
\r
6660 <param name="highIsValid">True if the cut function is positive somewhere
\r
6661 on this collection.</param>
\r
6662 <returns></returns>
\r
6664 <member name="M:C5.SortedArray`1.RangeAll">
\r
6666 Create a directed collection with the same items as this collection.
\r
6668 <returns>The result directed collection.</returns>
\r
6670 <member name="M:C5.SortedArray`1.AddSorted(System.Collections.Generic.IEnumerable{`0})">
\r
6672 Add all the items from another collection with an enumeration order that
\r
6673 is increasing in the items.
\r
6674 <exception cref="T:System.ArgumentException"/> if the enumerated items turns out
\r
6675 not to be in increasing order.
\r
6677 <param name="items">The collection to add.</param>
\r
6679 <member name="M:C5.SortedArray`1.RemoveRangeFrom(`0)">
\r
6681 Remove all items of this collection above or at a supplied threshold.
\r
6683 <param name="low">The lower threshold (inclusive).</param>
\r
6685 <member name="M:C5.SortedArray`1.RemoveRangeFromTo(`0,`0)">
\r
6687 Remove all items of this collection between two supplied thresholds.
\r
6689 <param name="low">The lower threshold (inclusive).</param>
\r
6690 <param name="hi">The upper threshold (exclusive).</param>
\r
6692 <member name="M:C5.SortedArray`1.RemoveRangeTo(`0)">
\r
6694 Remove all items of this collection below a supplied threshold.
\r
6696 <param name="hi">The upper threshold (exclusive).</param>
\r
6698 <member name="M:C5.SortedArray`1.Contains(`0)">
\r
6700 Check if this collection contains (an item equivalent to according to the
\r
6701 itemhasher) a particular value.
\r
6703 <param name="item">The value to check for.</param>
\r
6704 <returns>True if the items is in this collection.</returns>
\r
6706 <member name="M:C5.SortedArray`1.Find(`0@)">
\r
6708 Check if this collection contains an item equivalent according to the
\r
6709 itemhasher to a particular value. If so, return in the ref argument (a
\r
6710 binary copy of) the actual value found.
\r
6712 <param name="item">The value to look for.</param>
\r
6713 <returns>True if the items is in this collection.</returns>
\r
6715 <member name="M:C5.SortedArray`1.FindOrAdd(`0@)">
\r
6717 Check if this collection contains an item equivalent according to the
\r
6718 itemhasher to a particular value. If so, return in the ref argument (a
\r
6719 binary copy of) the actual value found. Else, add the item to the collection.
\r
6721 <param name="item">The value to look for.</param>
\r
6722 <returns>True if the item was added (hence not found).</returns>
\r
6724 <member name="M:C5.SortedArray`1.Update(`0)">
\r
6726 Check if this collection contains an item equivalent according to the
\r
6727 itemhasher to a particular value. If so, update the item in the collection
\r
6728 to with a binary copy of the supplied value. If the collection has bag semantics,
\r
6729 it is implementation dependent if this updates all equivalent copies in
\r
6730 the collection or just one.
\r
6732 <param name="item">Value to update.</param>
\r
6733 <returns>True if the item was found and hence updated.</returns>
\r
6735 <member name="M:C5.SortedArray`1.UpdateOrAdd(`0)">
\r
6737 Check if this collection contains an item equivalent according to the
\r
6738 itemhasher to a particular value. If so, update the item in the collection
\r
6739 to with a binary copy of the supplied value; else add the value to the collection.
\r
6741 <param name="item">Value to add or update.</param>
\r
6742 <returns>True if the item was found and updated (hence not added).</returns>
\r
6744 <member name="M:C5.SortedArray`1.Remove(`0)">
\r
6746 Remove a particular item from this collection. If the collection has bag
\r
6747 semantics only one copy equivalent to the supplied item is removed.
\r
6749 <param name="item">The value to remove.</param>
\r
6750 <returns>True if the item was found (and removed).</returns>
\r
6752 <member name="M:C5.SortedArray`1.RemoveWithReturn(`0@)">
\r
6754 Remove a particular item from this collection if found. If the collection
\r
6755 has bag semantics only one copy equivalent to the supplied item is removed,
\r
6756 which one is implementation dependent.
\r
6757 If an item was removed, report a binary copy of the actual item removed in
\r
6760 <param name="item">The value to remove on input.</param>
\r
6761 <returns>True if the item was found (and removed).</returns>
\r
6763 <member name="M:C5.SortedArray`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
6765 Remove all items in another collection from this one.
\r
6767 <param name="items">The items to remove.</param>
\r
6769 <member name="M:C5.SortedArray`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
6771 Remove all items not in some other collection from this one.
\r
6773 <param name="items">The items to retain.</param>
\r
6775 <member name="M:C5.SortedArray`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
6777 Check if this collection contains all the values in another collection.
\r
6778 Multiplicities are not taken into account.
\r
6780 <param name="items">The </param>
\r
6781 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
6783 <member name="M:C5.SortedArray`1.ContainsCount(`0)">
\r
6785 Count the number of items of the collection equal to a particular value.
\r
6786 Returns 0 if and only if the value is not in the collection.
\r
6788 <param name="item">The value to count.</param>
\r
6789 <returns>The number of copies found (0 or 1).</returns>
\r
6791 <member name="M:C5.SortedArray`1.RemoveAllCopies(`0)">
\r
6793 Remove all (0 or 1) items equivalent to a given value.
\r
6795 <param name="item">The value to remove.</param>
\r
6797 <member name="M:C5.SortedArray`1.Check">
\r
6799 Check the integrity of the internal data structures of this collection.
\r
6800 Only avaliable in DEBUG builds???
\r
6802 <returns>True if check does not fail.</returns>
\r
6804 <member name="M:C5.SortedArray`1.Add(`0)">
\r
6806 Add an item to this collection if possible. If this collection has set
\r
6807 semantics, the item will be added if not already in the collection. If
\r
6808 bag semantics, the item will always be added.
\r
6810 <param name="item">The item to add.</param>
\r
6811 <returns>True if item was added.</returns>
\r
6813 <member name="M:C5.SortedArray`1.AddAll(System.Collections.Generic.IEnumerable{`0})">
\r
6815 Add the elements from another collection to this collection. If this
\r
6816 collection has set semantics, only items not already in the collection
\r
6819 <param name="items">The items to add.</param>
\r
6821 <member name="M:C5.SortedArray`1.AddAll``1(System.Collections.Generic.IEnumerable{``0})">
\r
6823 Add the elements from another collection with a more specialized item type
\r
6824 to this collection. Since this
\r
6825 collection has set semantics, only items not already in the collection
\r
6828 <typeparam name="U">The type of items to add</typeparam>
\r
6829 <param name="items">The items to add</param>
\r
6831 <member name="M:C5.SortedArray`1.FindMin">
\r
6833 Find the current least item of this priority queue.
\r
6835 <returns>The least item.</returns>
\r
6837 <member name="M:C5.SortedArray`1.DeleteMin">
\r
6839 Remove the least item from this priority queue.
\r
6841 <returns>The removed item.</returns>
\r
6843 <member name="M:C5.SortedArray`1.FindMax">
\r
6845 Find the current largest item of this priority queue.
\r
6847 <returns>The largest item.</returns>
\r
6849 <member name="M:C5.SortedArray`1.DeleteMax">
\r
6851 Remove the largest item from this priority queue.
\r
6853 <returns>The removed item.</returns>
\r
6855 <member name="M:C5.SortedArray`1.IndexOf(`0)">
\r
6857 Searches for an item in the list going forwrds from the start.
\r
6859 <param name="item">Item to search for.</param>
\r
6860 <returns>Index of item from start.</returns>
\r
6862 <member name="M:C5.SortedArray`1.LastIndexOf(`0)">
\r
6864 Searches for an item in the list going backwords from the end.
\r
6866 <param name="item">Item to search for.</param>
\r
6867 <returns>Index of of item from the end.</returns>
\r
6869 <member name="M:C5.SortedArray`1.RemoveAt(System.Int32)">
\r
6871 Remove the item at a specific position of the list.
\r
6872 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
6873 >= the size of the collection.
\r
6875 <param name="i">The index of the item to remove.</param>
\r
6876 <returns>The removed item.</returns>
\r
6878 <member name="M:C5.SortedArray`1.RemoveInterval(System.Int32,System.Int32)">
\r
6880 Remove all items in an index interval.
\r
6881 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
6883 <param name="start">The index of the first item to remove.</param>
\r
6884 <param name="count">The number of items to remove.</param>
\r
6886 <member name="M:C5.SortedArray`1.C5#IDirectedEnumerable{T}#Backwards">
\r
6888 Create a collection containing the same items as this collection, but
\r
6889 whose enumerator will enumerate the items backwards. The new collection
\r
6890 will become invalid if the original is modified. Method typicaly used as in
\r
6891 <code>foreach (T x in coll.Backwards()) {...}</code>
\r
6893 <returns>The backwards collection.</returns>
\r
6895 <member name="P:C5.SortedArray`1.Features">
\r
6897 A debugging artifact. To be removed.
\r
6901 <member name="P:C5.SortedArray`1.ContainsSpeed">
\r
6903 The value is symbolic indicating the type of asymptotic complexity
\r
6904 in terms of the size of this collection (worst-case).
\r
6906 <value>Speed.Log</value>
\r
6908 <member name="P:C5.SortedArray`1.AllowsDuplicates">
\r
6912 <value>False since this collection has set semantics</value>
\r
6914 <member name="P:C5.SortedArray`1.Comparer">
\r
6916 The comparer object supplied at creation time for this collection
\r
6918 <value>The comparer</value>
\r
6920 <member name="P:C5.SortedArray`1.Item(System.Int32)">
\r
6922 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
6923 >= the size of the collection.
\r
6925 <value>The i'th item of this list.</value>
\r
6926 <param name="i">the index to lookup</param>
\r
6928 <member name="T:C5.SortedArray`1.Feature">
\r
6930 A debugging artifact. To be removed.
\r
6933 <member name="F:C5.SortedArray`1.Feature.Standard">
\r
6935 A debugging artifact. To be removed.
\r
6938 <member name="T:C5.HashedArrayList`1">
\r
6940 A set collection based on a dynamic array combined with a hash index
\r
6941 for item to index lookup.
\r
6944 <member name="M:C5.HashedArrayList`1.indexOf(`0)">
\r
6946 Internal version of IndexOf without modification checks.
\r
6948 <param name="item">Item to look for</param>
\r
6949 <returns>The index of first occurrence</returns>
\r
6951 <member name="M:C5.HashedArrayList`1.lastIndexOf(`0)">
\r
6953 Internal version of LastIndexOf without modification checks.
\r
6955 <param name="item">Item to look for</param>
\r
6956 <returns>The index of last occurrence</returns>
\r
6958 <member name="M:C5.HashedArrayList`1.insert(System.Int32,`0)">
\r
6960 Internal version of Insert with no modification checks.
\r
6961 <exception cref="T:System.ArgumentException"/> if item already in list.
\r
6963 <param name="i">Index to insert at</param>
\r
6964 <param name="item">Item to insert</param>
\r
6966 <member name="M:C5.HashedArrayList`1.removeAt(System.Int32)">
\r
6968 Internal version of RemoveAt with no modification checks.
\r
6970 <param name="i">Index to remove at</param>
\r
6971 <returns>The removed item</returns>
\r
6973 <member name="M:C5.HashedArrayList`1.#ctor">
\r
6975 Create a hashed array list with the natural hasher
\r
6978 <member name="M:C5.HashedArrayList`1.#ctor(System.Int32)">
\r
6980 Create a hashed array list with the natural hasher and specified capacity
\r
6982 <param name="cap">The initial capacity</param>
\r
6984 <member name="M:C5.HashedArrayList`1.#ctor(C5.IHasher{`0})">
\r
6986 Create a hashed array list with an external hasher
\r
6988 <param name="hasher">The external hasher</param>
\r
6990 <member name="M:C5.HashedArrayList`1.#ctor(System.Int32,C5.IHasher{`0})">
\r
6992 Create a hashed array list with an external hasher and specified capacity
\r
6994 <param name="capacity">The initial capacity</param>
\r
6995 <param name="hasher">The external hasher</param>
\r
6997 <member name="M:C5.HashedArrayList`1.InsertAll(System.Int32,System.Collections.Generic.IEnumerable{`0})">
\r
6999 Insert into this list all items from an enumerable collection starting
\r
7000 at a particular index.
\r
7001 <exception cref="T:System.IndexOutOfRangeException"/> if i is negative or
\r
7002 > the size of the collection.
\r
7003 <exception cref="T:System.InvalidOperationException"/> if one of the items to insert is
\r
7004 already in the list.
\r
7006 <param name="i">Index to start inserting at</param>
\r
7007 <param name="items">Items to insert</param>
\r
7009 <member name="M:C5.HashedArrayList`1.InsertBefore(`0,`0)">
\r
7011 Insert an item right before the first occurrence of some target item.
\r
7012 <exception cref="T:System.ArgumentException"/> if target is not found.
\r
7013 <exception cref="T:System.InvalidOperationException"/> if the item to insert is
\r
7014 already in the list.
\r
7016 <param name="item">The item to insert.</param>
\r
7017 <param name="target">The target before which to insert.</param>
\r
7019 <member name="M:C5.HashedArrayList`1.InsertAfter(`0,`0)">
\r
7021 Insert an item right after the last(???) occurrence of some target item.
\r
7022 <exception cref="T:System.ArgumentException"/> if target is not found.
\r
7023 <exception cref="T:System.InvalidOperationException"/> if the item to insert is
\r
7024 already in the list.
\r
7026 <param name="item">The item to insert.</param>
\r
7027 <param name="target">The target after which to insert.</param>
\r
7029 <member name="M:C5.HashedArrayList`1.View(System.Int32,System.Int32)">
\r
7031 Create a list view on this list.
\r
7032 <exception cref="T:System.ArgumentOutOfRangeException"/> if the view would not fit into
\r
7035 <param name="start">The index in this list of the start of the view.</param>
\r
7036 <param name="count">The size of the view.</param>
\r
7037 <returns>The new list view.</returns>
\r
7039 <member name="M:C5.HashedArrayList`1.Reverse(System.Int32,System.Int32)">
\r
7041 Reverst part of the list so the items are in the opposite sequence order.
\r
7042 <exception cref="T:System.ArgumentException"/> if the count is negative.
\r
7043 <exception cref="T:System.ArgumentOutOfRangeException"/> if the part does not fit
\r
7046 <param name="start">The index of the start of the part to reverse.</param>
\r
7047 <param name="count">The size of the part to reverse.</param>
\r
7049 <member name="M:C5.HashedArrayList`1.Sort(C5.IComparer{`0})">
\r
7051 Sort the items of the list according to a specific sorting order.
\r
7053 <param name="c">The comparer defining the sorting order.</param>
\r
7055 <member name="M:C5.HashedArrayList`1.Shuffle(System.Random)">
\r
7057 Shuffle the items of this list according to a specific random source.
\r
7059 <param name="rnd">The random source.</param>
\r
7061 <member name="M:C5.HashedArrayList`1.RemoveInterval(System.Int32,System.Int32)">
\r
7063 Remove all items in an index interval.
\r
7064 <exception cref="T:System.IndexOutOfRangeException"/>???.
\r
7066 <param name="start">The index of the first item to remove.</param>
\r
7067 <param name="count">The number of items to remove.</param>
\r
7069 <member name="M:C5.HashedArrayList`1.Contains(`0)">
\r
7071 Check if this collection contains (an item equivalent to according to the
\r
7072 itemhasher) a particular value.
\r
7074 <param name="item">The value to check for.</param>
\r
7075 <returns>True if the items is in this collection.</returns>
\r
7077 <member name="M:C5.HashedArrayList`1.Remove(`0)">
\r
7079 Remove the first copy of a particular item from this collection.
\r
7081 <param name="item">The value to remove.</param>
\r
7082 <returns>True if the item was found (and removed).</returns>
\r
7084 <member name="M:C5.HashedArrayList`1.RemoveAll(System.Collections.Generic.IEnumerable{`0})">
\r
7086 Remove all items in another collection from this one, taking multiplicities into account.
\r
7087 Matching items will be removed from the front. Current implementation is not optimal.
\r
7089 <param name="items">The items to remove.</param>
\r
7091 <member name="M:C5.HashedArrayList`1.Clear">
\r
7093 Remove all items from this collection, resetting internal array size.
\r
7096 <member name="M:C5.HashedArrayList`1.RetainAll(System.Collections.Generic.IEnumerable{`0})">
\r
7098 Remove all items not in some other collection from this one.
\r
7100 <param name="items">The items to retain.</param>
\r
7102 <member name="M:C5.HashedArrayList`1.ContainsAll(System.Collections.Generic.IEnumerable{`0})">
\r
7104 Check if this collection contains all the values in another collection.
\r
7106 <param name="items">The </param>
\r
7107 <returns>True if all values in <code>items</code>is in this collection.</returns>
\r
7109 <member name="M:C5.HashedArrayList`1.ContainsCount(`0)">
\r
7111 Count the number of items of the collection equal to a particular value.
\r
7112 Returns 0 if and only if the value is not in the collection.
\r
7114 <param name="item">The value to count.</param>
\r
7115 <returns>The number of copies found (0 or 1).</returns>
\r
7117 <member name="M:C5.HashedArrayList`1.RemoveAllCopies(`0)">
\r
7119 Remove all items equal to a given one.
\r
7121 <param name="item">The value to remove.</param>
\r
7123 <member name="M:C5.HashedArrayList`1.Check">
\r
7125 Check the integrity of the internal data structures of this array list.
\r
7127 <returns>True if check does not fail.</returns>
\r
7129 <member name="M:C5.HashedArrayList`1.Add(`0)">
\r
7131 Add an item to end of this list if not already in list.
\r
7133 <param name="item">The item to add.</param>
\r
7134 <returns>True if item was added</returns>
\r
7136 <member name="P:C5.HashedArrayList`1.ContainsSpeed">
\r
7138 The value is symbolic indicating the type of asymptotic complexity
\r
7139 in terms of the size of this collection (expected).
\r
7141 <value>Speed.Constant</value>
\r
7143 <member name="P:C5.HashedArrayList`1.AllowsDuplicates">
\r
7147 <value>False, indicating hashed array list has set semantics.</value>
\r
projects / mono.git / blob