/// <summary> /// Create a dynamic sorted array with an external comparer. /// <para>The itemequalityComparer will be compatible /// <see cref="T:C5.ComparerZeroHashCodeEqualityComparer`1"/> since the /// default equalityComparer for T (<see cref="P:C5.EqualityComparer`1.Default"/>) /// is unlikely to be compatible with the external comparer. This makes the /// array inadequate for use as item in a collection of unsequenced or sequenced sets or bags /// (<see cref="T:C5.ICollection`1"/> and <see cref="T:C5.ISequenced`1"/>) /// </para> /// </summary> /// <param name="comparer">The comparer</param> public SortedArray(SCG.IComparer <T> comparer) : this(8, comparer) { }
private TreeDictionary(SCG.IComparer <K> comparer, SCG.IEqualityComparer <K> equalityComparer) : base(comparer, equalityComparer) { pairs = sortedpairs = new TreeSet <System.Collections.Generic.KeyValuePair <K, V> >(new KeyValuePairComparer <K, V>(comparer)); }
internal Sorter(T[] a, SCG.IComparer <T> c) { this.a = a; this.c = c; }
/// <summary> /// Create an interval heap with external item comparer and prescribed initial capacity /// </summary> /// <param name="comparer">The external comparer</param> /// <param name="capacity">The initial capacity</param> /// <param name = "memoryType"></param> public IntervalHeap(int capacity, SCG.IComparer <T> comparer, MemoryType memoryType = MemoryType.Normal) : this(capacity, comparer, new ComparerZeroHashCodeEqualityComparer <T>(comparer), memoryType) { }
// System.Array.Sort(T[], int, int, SCG.IComparer<T>) public static void Sort <T>(T[] arr, int i, int n, SCG.IComparer <T> cmp) { new WrappedArray <T>(arr).View(i, n).Sort(cmp); }
TreeDictionary(SCG.IComparer <K> comparer, SCG.IEqualityComparer <K> equalityComparer) : base(comparer, equalityComparer) { pairs = sortedpairs = new TreeSet <KeyValuePair <K, V> >(new KeyValuePairComparer <K, V>(comparer)); }
/// <summary> /// Create an interval heap with external item comparer and prescribed initial capacity /// </summary> /// <param name="comparer">The external comparer</param> /// <param name="capacity">The initial capacity</param> public IntervalHeap(int capacity, SCG.IComparer <T> comparer) : this(capacity, comparer, new ComparerZeroHashCodeEqualityComparer <T>(comparer)) { }
static SCG.IComparer <T> ReverseComparer <T>(SCG.IComparer <T> cmp) => ComparerFactory <T> .CreateComparer((item1, item2) => cmp.Compare(item2, item1));
/// <summary> /// Create a dynamic sorted array with an external comparer, an external item equalityComparer /// and prescribed initial capacity. This is the constructor to use if the collection /// will be used as item in a hash table based collection. /// </summary> /// <param name="capacity">The capacity</param> /// <param name="comparer">The item comparer</param> /// <param name="equalityComparer">The item equalityComparer (assumed compatible)</param> public SortedArray(int capacity, SCG.IComparer <T> comparer, SCG.IEqualityComparer <T> equalityComparer) : base(capacity, equalityComparer) { _comparer = comparer ?? throw new NullReferenceException("Comparer cannot be null"); }
/// <summary> /// Create a red-black tree dictionary using an external comparer for keys. /// </summary> /// <param name="comparer">The external comparer</param> public SortedArrayDictionary(SCG.IComparer <K> comparer) : this(comparer, new ComparerZeroHashCodeEqualityComparer <K>(comparer)) { }
/// <summary> /// /// </summary> /// <param name="comparer"></param> /// <param name="equalityComparer"></param> /// <param name="capacity"></param> public SortedArrayDictionary(int capacity, SCG.IComparer <K> comparer, SCG.IEqualityComparer <K> equalityComparer) : base(comparer, equalityComparer) { pairs = sortedpairs = new SortedArray <KeyValuePair <K, V> >(capacity, new KeyValuePairComparer <K, V>(comparer)); }
/// <summary> /// Create a dynamic sorted array with an external comparer /// and prescribed initial capacity. /// <para>The itemequalityComparer will be a compatible /// <see cref="T:C5.ComparerZeroHashCodeEqualityComparer`1"/> since the /// default equalityComparer for T (<see cref="P:C5.EqualityComparer`1.Default"/>) /// is unlikely to be compatible with the external comparer. This makes the /// sorted array inadequate for use as item in a collection of unsequenced or sequenced sets or bags /// (<see cref="T:C5.ICollection`1"/> and <see cref="T:C5.ISequenced`1"/>) /// </para> /// </summary> /// <param name="capacity">The capacity</param> /// <param name="comparer">The comparer</param> /// <param name="memoryType">The type of memory for the enumerator used to iterate the collection</param> public SortedArray(int capacity, SCG.IComparer <T> comparer, MemoryType memoryType = MemoryType.Normal) : this(capacity, comparer, new ComparerZeroHashCodeEqualityComparer <T>(comparer), memoryType) { }
/// <summary> /// Create a dynamic sorted array with an external comparer. /// <para>The itemequalityComparer will be compatible /// <see cref="T:C5.ComparerZeroHashCodeEqualityComparer`1"/> since the /// default equalityComparer for T (<see cref="P:C5.EqualityComparer`1.Default"/>) /// is unlikely to be compatible with the external comparer. This makes the /// array inadequate for use as item in a collection of unsequenced or sequenced sets or bags /// (<see cref="T:C5.ICollection`1"/> and <see cref="T:C5.ISequenced`1"/>) /// </para> /// </summary> /// <param name="comparer">The comparer</param> /// <param name="memoryType">The type of memory for the enumerator used to iterate the collection</param> public SortedArray(SCG.IComparer <T> comparer, MemoryType memoryType = MemoryType.Normal) : this(8, comparer, memoryType) { }
public void NotComparable() { SCG.IComparer <object> foo = Comparer <object> .Default; }
/// <summary> /// Create a dynamic sorted array with an external comparer /// and prescribed initial capacity. /// <para>The itemequalityComparer will be a compatible /// <see cref="T:C5.ComparerZeroHashCodeEqualityComparer`1"/> since the /// default equalityComparer for T (<see cref="P:C5.EqualityComparer`1.Default"/>) /// is unlikely to be compatible with the external comparer. This makes the /// sorted array inadequate for use as item in a collection of unsequenced or sequenced sets or bags /// (<see cref="T:C5.ICollection`1"/> and <see cref="T:C5.ISequenced`1"/>) /// </para> /// </summary> /// <param name="capacity">The capacity</param> /// <param name="comparer">The comparer</param> public SortedArray(int capacity, SCG.IComparer <T> comparer) : this(capacity, comparer, new ComparerZeroHashCodeEqualityComparer <T>(comparer)) { }
/// <summary> /// /// </summary> /// <param name="comparer"></param> /// <returns></returns> public bool IsSorted(SCG.IComparer <T> comparer) { return(innerlist.IsSorted(comparer)); }
/// <summary> /// Create a red-black tree dictionary using an external comparer for keys. /// </summary> /// <param name="comparer">The external comparer</param> public TreeDictionary(SCG.IComparer <K> comparer) : this(comparer, new ComparerZeroHashCodeEqualityComparer <K>(comparer)) { }
/// <summary> /// /// </summary> /// <param name="comparer"></param> public void Sort(SCG.IComparer <T> comparer) { innerlist.Sort(comparer); }
/// <summary> /// Create an interval heap with external item comparer and default initial capacity (16) /// </summary> /// <param name="comparer">The external comparer</param> public IntervalHeap(SCG.IComparer <T> comparer) : this(16, comparer) { }
/// <summary> /// /// </summary> /// <param name="keycomparer"></param> /// <param name="keyequalityComparer"></param> protected SortedDictionaryBase(SCG.IComparer <K> keycomparer, SCG.IEqualityComparer <K> keyequalityComparer) : base(keyequalityComparer) { this.keycomparer = keycomparer; }
/// <summary> /// Create an interval heap with external item comparer and default initial capacity (16) /// </summary> /// <param name="comparer">The external comparer</param> /// <param name = "memoryType"></param> public IntervalHeap(SCG.IComparer <T> comparer, MemoryType memoryType = MemoryType.Normal) : this(16, comparer, memoryType) { }
internal SortedKeysCollection(ISortedDictionary <K, V> sorteddict, ISorted <SCG.KeyValuePair <K, V> > sortedpairs, SCG.IComparer <K> comparer, SCG.IEqualityComparer <K> itemequalityComparer) : base(itemequalityComparer) { this.sorteddict = sorteddict; this.sortedpairs = sortedpairs; this.comparer = comparer; }
// System.Array.Sort(T[], SCG.IComparer<T>) public static void Sort <T>(T[] arr, SCG.IComparer <T> cmp) { new WrappedArray <T>(arr).Sort(cmp); }
/// <summary> /// Create a red-black tree dictionary using an external comparer for keys. /// </summary> /// <param name="comparer">The external comparer</param> /// <param name = "memoryType"></param> public TreeDictionary(SCG.IComparer <K> comparer, MemoryType memoryType = MemoryType.Normal) : this(comparer, new ComparerZeroHashCodeEqualityComparer <K>(comparer)) { }
/// <summary> /// Create a trivial <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> compatible with the /// <see cref="T:System.Collections.Generic.IComparer`1"/> <code>comparer</code> /// </summary> /// <param name="comparer"></param> public ComparerZeroHashCodeEqualityComparer(SCG.IComparer <T> comparer) { this.comparer = comparer ?? throw new NullReferenceException("Comparer cannot be null"); }
public OptionGroup(string id, string name, string description, OptionGroupRequirement require, bool requireExplicitAssignment, SCG.IComparer <string> keyComparer) { Debug.Assert(!String.IsNullOrEmpty(id)); Debug.Assert(keyComparer != null); mId = id; mName = name; mDescription = description; mRequire = require; mOptions = new TreeDictionary <string, Option>(keyComparer); mRequireExplicitAssignment = requireExplicitAssignment; }