private static IOrderedDataProducer <TSource> OrderBy <TSource, TKey>(IDataProducer <TSource> source, Func <TSource, TKey> selector, IComparer <TKey> comparer, bool descending)
{
source.ThrowIfNull("source");
comparer.ThrowIfNull("comparer");
IComparer <TSource> itemComparer = new ProjectionComparer <TSource, TKey>(selector, comparer);
switch (descending)
{
case true:
itemComparer = itemComparer.Reverse();
break;
}
// first, discard any existing "order by"s by going back to the producer
IOrderedDataProducer <TSource> orderedProducer;
bool first = true;
while ((orderedProducer = source as IOrderedDataProducer <TSource>) != null)
{
switch (first)
{
case true:
// keep the top-most comparer to enforce a balanced sort
itemComparer = new LinkedComparer <TSource>(itemComparer, orderedProducer.Comparer);
first = false;
break;
}
source = orderedProducer.BaseProducer;
}
return(new OrderedDataProducer <TSource>(source, itemComparer));
}
public static TSource MaxBy <TSource, TKey>(this IEnumerable <TSource> source,
Func <TSource, TKey> selector, IComparer <TKey> comparer)
{
source.ThrowIfNull("source");
selector.ThrowIfNull("selector");
comparer.ThrowIfNull("comparer");
using (IEnumerator <TSource> sourceIterator = source.GetEnumerator())
{
if (!sourceIterator.MoveNext())
{
throw new InvalidOperationException("Sequence was empty");
}
TSource max = sourceIterator.Current;
TKey maxKey = selector(max);
while (sourceIterator.MoveNext())
{
TSource candidate = sourceIterator.Current;
TKey candidateProjected = selector(candidate);
if (comparer.Compare(candidateProjected, maxKey) > 0)
{
max = candidate;
maxKey = candidateProjected;
}
}
return(max);
}
}
/// <summary>
/// Create a new LinkedComparer
/// </summary>
/// <param name="primary">The first comparison to use</param>
/// <param name="secondary">The next level of comparison if the primary returns 0 (equivalent)</param>
public LinkedComparer(IComparer <T> primary, IComparer <T> secondary)
{
primary.ThrowIfNull("primary");
secondary.ThrowIfNull("secondary");
this.primary = primary;
this.secondary = secondary;
}
private static IOrderedDataProducer <TSource> ThenBy <TSource, TKey>(IOrderedDataProducer <TSource> source, DotNet20.Func <TSource, TKey> selector, IComparer <TKey> comparer, bool descending)
{
comparer.ThrowIfNull("comparer");
IComparer <TSource> itemComparer = new ProjectionComparer <TSource, TKey>(selector, comparer);
if (descending)
{
itemComparer = itemComparer.Reverse();
}
itemComparer = new LinkedComparer <TSource>(source.Comparer, itemComparer);
return(new OrderedDataProducer <TSource>(source, itemComparer));
}
public BundleContents GetContents(IFileSystem fileSystem, IComparer <AssetFile> assetOrder, IEnumerable <IAssetTransformer> transformers)
{
fileSystem.ThrowIfNull("fileSystem");
assetOrder.ThrowIfNull("assetOrder");
transformers.ThrowIfNull("transformers");
AssetFile[] orderedAssets = _assets
.SelectMany(arg => arg.ResolveAssetFiles(fileSystem))
.OrderBy(arg => arg, assetOrder)
.ToArray();
return(GetContents(fileSystem, orderedAssets, new DelimiterConcatenator(), transformers));
}
public BundleWatcher(Bundle bundle, IFileSystem fileSystem, IComparer<AssetFile> assetOrder, IEnumerable<IAssetTransformer> transformers)
{
bundle.ThrowIfNull("bundle");
fileSystem.ThrowIfNull("fileSystem");
assetOrder.ThrowIfNull("assetOrder");
transformers.ThrowIfNull("transformers");
_bundle = bundle;
_assetOrder = assetOrder;
_transformers = transformers.ToArray();
_fileSystem = fileSystem;
_watchTimer.Elapsed += WatchTimerElapsed;
RefreshContents();
WatchForChanges();
}
public BundleWatcher(Bundle bundle, IFileSystem fileSystem, IComparer <AssetFile> assetOrder, IEnumerable <IAssetTransformer> transformers)
{
bundle.ThrowIfNull("bundle");
fileSystem.ThrowIfNull("fileSystem");
assetOrder.ThrowIfNull("assetOrder");
transformers.ThrowIfNull("transformers");
_bundle = bundle;
_assetOrder = assetOrder;
_transformers = transformers.ToArray();
_fileSystem = fileSystem;
_watchTimer.Elapsed += WatchTimerElapsed;
RefreshContents();
WatchForChanges();
}
public static IEnumerable <T> Merge <T>(this IEnumerable <IOrderedEnumerable <T> > sources, IComparer <T> comparer)
{
sources.ThrowIfNull("sources");
comparer.ThrowIfNull("comparer");
var items = sources.Select(s => s.GetEnumerator()).ToArray();
if (items.Length > 1)
{
Comparison <Tuple <int, T> > comparison = (a, b) => comparer.Compare(a.Item2, b.Item2);
// Create heap
var heap = new BinaryHeap <Tuple <int, T> >(items.Length, new ComparisonComparer <Tuple <int, T> >(comparison));
// Populate heap
for (var i = 0; i < items.Length; i++)
{
if (items[i].MoveNext())
{
heap.Add(Tuple.Create(i, items[i].Current));
}
}
// Read from heap
while (heap.Count > 0)
{
var tuple = heap.Remove();
yield return(tuple.Item2);
if (items[tuple.Item1].MoveNext())
{
heap.Add(Tuple.Create(tuple.Item1, items[tuple.Item1].Current));
}
else
{
var item = items.Select((s, i) => new { Source = s, Index = i }).FirstOrDefault(a => a.Source.MoveNext());
if (item != null)
{
heap.Add(Tuple.Create(item.Index, item.Source.Current));
}
}
}
}
else if (items.Length == 1)
{
while (items[0].MoveNext())
{
yield return(items[0].Current);
}
}
}
public BundleRoute(Bundle bundle, string routeName, string relativePath, IComparer<AssetFile> assetOrder, IAssetConcatenator concatenator, IEnumerable<IAssetTransformer> transformers)
{
bundle.ThrowIfNull("bundle");
routeName.ThrowIfNull("routeName");
relativePath.ThrowIfNull("relativePath");
assetOrder.ThrowIfNull("assetOrder");
concatenator.ThrowIfNull("concatenator");
transformers.ThrowIfNull("transformers");
_bundle = bundle;
_routeName = routeName;
_relativePath = relativePath;
_assetOrder = assetOrder;
_concatenator = concatenator;
_transformers = transformers;
}
public BundleRoute(Bundle bundle, string routeName, string relativePath, IComparer <AssetFile> assetOrder, IAssetConcatenator concatenator, IEnumerable <IAssetTransformer> transformers)
{
bundle.ThrowIfNull("bundle");
routeName.ThrowIfNull("routeName");
relativePath.ThrowIfNull("relativePath");
assetOrder.ThrowIfNull("assetOrder");
concatenator.ThrowIfNull("concatenator");
transformers.ThrowIfNull("transformers");
_bundle = bundle;
_routeName = routeName;
_relativePath = relativePath;
_assetOrder = assetOrder;
_concatenator = concatenator;
_transformers = transformers;
}
public AutoRouteCollection JavaScriptBundle(Bundle bundle, string routeName, Scheme scheme, string relativePath, IComparer <AssetFile> assetOrder, IAssetConcatenator concatenator, IEnumerable <IAssetTransformer> transformers)
{
ThrowIfNoContainer();
bundle.ThrowIfNull("bundle");
routeName.ThrowIfNull("routeName");
relativePath.ThrowIfNull("relativePath");
assetOrder.ThrowIfNull("assetOrder");
concatenator.ThrowIfNull("concatenator");
transformers.ThrowIfNull("transformers");
var watcher = new BundleWatcher(bundle, _container.GetInstance <IFileSystem>(), assetOrder, concatenator, transformers);
var guidFactory = _container.GetInstance <IGuidFactory>();
var httpRuntime = _container.GetInstance <IHttpRuntime>();
var systemClock = _container.GetInstance <ISystemClock>();
var route = new JavaScriptBundleWatcherRoute(routeName, guidFactory.Random(), scheme, relativePath, watcher, httpRuntime, systemClock);
return(AdditionalRoutes(route));
}
public AutoRouteCollection CssBundle(Bundle bundle, string routeName, string relativePath, IComparer <AssetFile> assetOrder, IAssetConcatenator concatenator, IEnumerable <IAssetTransformer> transformers)
{
ThrowIfNoBundleDependencyContainer();
bundle.ThrowIfNull("bundle");
routeName.ThrowIfNull("routeName");
relativePath.ThrowIfNull("relativePath");
assetOrder.ThrowIfNull("assetOrder");
concatenator.ThrowIfNull("concatenator");
transformers.ThrowIfNull("transformers");
var watcher = new BundleWatcher(bundle, _bundleDependencyContainer.GetInstance <IFileSystem>(), assetOrder, concatenator, transformers);
var route = new CssBundleWatcherRoute(
routeName,
_bundleDependencyContainer.GetInstance <IGuidFactory>(),
relativePath,
watcher,
_bundleDependencyContainer.GetInstance <IHttpRuntime>(),
_bundleDependencyContainer.GetInstance <ISystemClock>());
return(AdditionalRoutes(route));
}
/// <summary>
/// Creates a new reversing comparer.
/// </summary>
/// <param name="original">The original comparer to use for comparisons.</param>
public ReverseComparer(IComparer <T> original)
{
original.ThrowIfNull("original");
OriginalComparer = original;
}
public ReverseComparer(IComparer <T> original)
{
original.ThrowIfNull(nameof(original));
OriginalComparer = original;
}
public BundleContents GetContents(IFileSystem fileSystem, IComparer<AssetFile> assetOrder, IEnumerable<IAssetTransformer> transformers)
{
fileSystem.ThrowIfNull("fileSystem");
assetOrder.ThrowIfNull("assetOrder");
transformers.ThrowIfNull("transformers");
AssetFile[] orderedAssets = _assets
.SelectMany(arg => arg.ResolveAssetFiles(fileSystem))
.OrderBy(arg => arg, assetOrder)
.ToArray();
return GetContents(fileSystem, orderedAssets, new DelimiterConcatenator(), transformers);
}
public InverseComparer(IComparer <T> comparer)
{
_comparer = comparer.ThrowIfNull(nameof(comparer));
}
public ReverseComparer(IComparer <T> comparer)
{
comparer.ThrowIfNull("comparer");
_comparer = comparer;
}
