/// <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;
}
