private void btn_Graph_Compare_Click(object sender, RoutedEventArgs e)
{
var data = m_DataProcessingHelper.getData();
var units = m_DataProcessingHelper.getUnits();
if (data != null && data.Count() > 0 && units != null)
{
string title = string.IsNullOrEmpty(m_DataProcessingHelper.getType())
? CompareHelper.DEFAULT_NAME
: m_DataProcessingHelper.getType();
CompareSource source = new CompareSource(title, data, units);
m_CompareHelper.AddSource(source);
}
}
public LibraryLoader(string dllName)
{
HModule = LoadLibrary(dllName);
if (HModule == IntPtr.Zero)
{
throw new Exception("failed to load dll: " + dllName);
}
IntPtr proc = GetProcAddress(HModule, "CompareSource");
if (proc == IntPtr.Zero)
{
throw new Exception("failed to find func: CompareSource");
}
Method = Marshal.GetDelegateForFunctionPointer(proc, typeof(CompareSource)) as CompareSource;
}
private void btn_Compare_Add_Click(object sender, RoutedEventArgs e)
{
try
{
var openResult = m_OpenManager.OpenMultiple(_graphfileextensions);
if (openResult != null)
{
foreach (var o in openResult)
{
var savedState = o.Value as SavedState;
if (savedState != null)
{
CompareSource source = new CompareSource(string.IsNullOrEmpty(o.Key) ? CompareHelper.DEFAULT_NAME : o.Key, savedState.Data.data, savedState.Data.units);
m_CompareHelper.AddSource(source);
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(Properties.Resources.common_error + " (" + ex.Message + ")");
}
}
/// <summary>
/// Returns the elements with the minimum key value by using the specified comparer to compare key values.
/// </summary>
/// <typeparam name="TSource">Source sequence element type.</typeparam>
/// <typeparam name="TKey">Key type.</typeparam>
/// <param name="source">Source sequence.</param>
/// <param name="keySelector">Key selector used to extract the key for each element in the sequence.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IList <TSource> MinBy <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector, Func <CompareSource <TKey>, IFullComparer <TKey> > comparerFactory)
{
var comparer = comparerFactory(CompareSource.For <TKey>());
return(source.MinBy(keySelector, comparer));
}
/// <summary>
/// Returns the minimum value in the enumerable sequence by using the specified comparer to compare values.
/// </summary>
/// <typeparam name="TSource">Source sequence element type.</typeparam>
/// <param name="source">Source sequence.</param>
/// <param name="comparerFactory">The definition of a comparer to compare elements.</param>
public static TSource Min <TSource>(this IEnumerable <TSource> source, Func <CompareSource <TSource>, IFullComparer <TSource> > comparerFactory)
{
var comparer = comparerFactory(CompareSource.For <TSource>());
return(source.Min(comparer));
}
/// <summary>
/// Performs a subsequent ordering of the elements in a sequence in descending order by using a specified comparer.
/// </summary>
/// <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelector">A function to extract a key from an element.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IOrderedEnumerable <T> ThenByDescending <T, TKey>(this IOrderedEnumerable <T> source, Func <T, TKey> keySelector, Func <CompareSource <TKey>, IFullComparer <TKey> > comparerFactory)
{
var comparer = comparerFactory(CompareSource.For <TKey>());
return(source.ThenByDescending(keySelector, comparer));
}
/// <summary>
/// Sorts the elements of a sequence in ascending order by using a specified comparer.
/// </summary>
/// <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelector">A function to extract a key from an element.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
public static IOrderedEnumerable <T> OrderBy <T, TKey>(this IEnumerable <T> source, Func <T, TKey> keySelector, Func <CompareSource <TKey>, IFullComparer <TKey> > comparerFactory)
{
var comparer = comparerFactory(CompareSource.For <TKey>());
return(source.OrderBy(keySelector, comparer));
}
/// <summary>
/// Performs a subsequent ordering of the elements in a sequence in ascending order by using a specified comparer.
/// </summary>
/// <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelector">A function to extract a key from an element.</param>
/// <param name="comparerFactory">The definition of a comparer to compare keys.</param>
/// <param name="descending">A value indicating whether the sorting is done in descending order. If <c>false</c> (the default), then the sort is in ascending order.</param>
public static IOrderedEnumerable <T> ThenBy <T, TKey>(this IOrderedEnumerable <T> source, Func <T, TKey> keySelector, Func <CompareSource <TKey>, IFullComparer <TKey> > comparerFactory, bool descending = false)
{
var comparer = comparerFactory(CompareSource.For <TKey>());
return(source.ThenBy(keySelector, descending ? comparer.Reverse() : comparer));
}
/// <summary>
/// Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
/// <typeparam name="TResult">The type of the objects derived from the elements in the source sequence to determine the minimum of.</typeparam>
/// <param name="source">An observable sequence to determine the mimimum element of.</param>
/// <param name="selector">A transform function to apply to each element.</param>
/// <param name="comparerFactory">The definition of a comparer to compare elements.</param>
public static IObservable <TResult> Min <TSource, TResult>(this IObservable <TSource> source, Func <TSource, TResult> selector, Func <CompareSource <TResult>, IFullComparer <TResult> > comparerFactory)
{
var comparer = comparerFactory(CompareSource.For <TResult>());
return(source.Min(selector, comparer));
}
/// <summary>
/// Returns the maximum value in an observable sequence according to the specified comparer.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
/// <param name="source">An observable sequence to determine the maximum element of.</param>
/// <param name="comparerFactory">The definition of a comparer to compare elements.</param>
public static IObservable <TSource> Max <TSource>(this IObservable <TSource> source, Func <CompareSource <TSource>, IFullComparer <TSource> > comparerFactory)
{
var comparer = comparerFactory(CompareSource.For <TSource>());
return(source.Max(comparer));
}
