public virtual IEnumerable <Lot <T> > RequestPermutations <T>( Lot <T> collection) { var r = this.rotator; for (var i = 0; i < collection.Count; ++i) { var switched = XLinkedList <T> .Create( Skip( collection, i)); for (var j = 0; j < i; ++j) { switched.AddTail( FirstOrDefault( Skip( collection, j))); } for (var k = 0; k < i; ++k) { yield return(r.Rotate(switched, k)); } } }
public virtual T Liken <T>( Func <T> factory, Lot <Action <T> > acts, long limiter) { var actee = factory(); FirstOrDefault( acts) ?.Invoke(actee); var firstHashCode = actee.GetHashCode(); foreach (var act in Skip(acts, 1)) { act(actee); if (Math.Abs(actee.GetHashCode() - firstHashCode) <= limiter) { continue; } return(this.Liken( factory, new XLinkedListLot <Action <T> >( XLinkedList <Action <T> > .Create( Except( acts, new[] { act }))), limiter)); } return(actee); }
public virtual void Order( Tree <T> tree) { var linkedList = new XLinkedList <T>(); var iterations = (int)(tree.Count / (double)this.numberOfSkips + 1); var subtractor = 0; while (subtractor < this.numberOfSkips) { for (var i = 0; i < iterations; ++i) { var amountToSkip = (this.numberOfSkips * (i + 1)) - (subtractor + 1); linkedList.AddTail( FirstOrDefault( Skip( tree, amountToSkip))); } ++subtractor; } this.currentTree = new XLinkedListLot <T>(linkedList); }
public virtual Lot <T> Act( Tree <T> tree, IEnumerable <Action <T> > actions) { var orderer = this.treeOrderer; if (orderer == null) { return(tree); } if (actions == null) { orderer.Order(tree); return(orderer.OrderedTree); } orderer.Order(tree); var actionEnumerator = actions.GetEnumerator(); var linkedList = new XLinkedList <T>(); foreach (var value in orderer.OrderedTree) { actionEnumerator.MoveNext(); actionEnumerator.Current?.Invoke(value); linkedList.AddTail(value); } actionEnumerator.Dispose(); return(new XLinkedListLot <T>( linkedList)); }
public virtual void PushRange( IEnumerable <T> source, long index, long length) { Lot <T> lot = new XLinkedListLot <T>( XLinkedList <T> .Create( source)); var array = new T[length - index]; long counter = zero; foreach (var item in lot) { if (counter < index) { continue; } if (counter >= length) { break; } array[counter] = item; ++counter; } this.stack.PushRange(array); }
public virtual void DoWork( IEnumerable <T> source, Action <T> longFunction) { var enumerator = source.GetEnumerator(); enumerator.MoveNext(); Lot <Thread> threads = new XLinkedListLot <Thread>(); foreach (var computation in this.computations) { var current = enumerator.Current; computation(current); var ts = new XLinkedList <Thread>(); ts.AddTail(new Thread(() => longFunction(current))); ts.Head?.Start(); threads = this.rotator.Rotate(ts, 1); if (!enumerator.MoveNext()) { break; } } foreach (var t in threads) { t.Join(); } enumerator.Dispose(); }
public virtual void Surge( Lot <IDisposable> disposables) { if (disposables == null) { return; } var dependencies = new XLinkedList <List <object> >(); foreach (var disposable in disposables) { dependencies.AddTail(new List <object>()); var dd = disposable.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic); var dToSurge = new List <IDisposable>(); foreach (var field in dd) { var value = field.GetValue(disposable); dependencies.Tail?.Add(value); if (field.FieldType == typeof(IDisposable)) { dToSurge.Add((IDisposable)value); } } this.Surge(new ListLot <IDisposable>(dToSurge)); // ReSharper disable once ImpureMethodCallOnReadonlyValueField this.martyr.BringToGod(disposables); var ll = this.illuminator.Illumine < LinkedListLot <IDisposable> >(dependencies); this.illuminator.Illumine <IDisposable>(ll); } }
public virtual T Illumine <T>( params object[] dependencies) { return(this.Illumine <T>( new XLinkedListLot <object>( XLinkedList <object> .Create( dependencies)))); }
protected virtual ICollection <DateTime> readAllTimestamps() { ICollection <DateTime> collection = new XLinkedList <DateTime>(); var md = this.mainDirectory; try { if (!Directory.Exists(md)) { Directory.CreateDirectory(md); } } catch { return(collection); } string[] allDataFiles; try { allDataFiles = Directory.GetFiles(md); } catch { return(collection); } foreach (var filePath in allDataFiles) { IEnumerable <string> lines; try { lines = File.ReadAllLines(filePath); } catch { continue; } foreach (var line in lines) { if (!long.TryParse(line, out var ticks)) { continue; } collection.Add(new DateTime(ticks)); } } collection = EnumerableHelpers.OrderBy( collection, timestamp => timestamp); return(collection); }
protected virtual ICollection <DateTime> allTimes() { var r = this.runner; return(XLinkedList <DateTime> .Create( EnumerableHelpers.OrderBy( r?.Run <TimestampReader>() ?.ReadAll(), ts => ts))); }
public virtual void Order( Tree <T> tree) { this.processNodes(tree.Node); this.setCurrentTree( new XLinkedListLot <T>( XLinkedList <T> .Create( OrderBy( tree, t => t.GetHashCode())))); }
public virtual void Handle( TimestampEditUi ui, HomeNavUi hnUi, HomeUi homeUi) { var r = this.runner; r?.Run <UiReaderWriter>(uiRW => { r.Run <TimestampReader>(reader => { var allColl = reader.ReadAll(); var ll = allColl as XLinkedList <DateTime> ?? XLinkedList <DateTime> .Create(allColl); const byte one = 1; if (ll.Count < one) { return; } var lastTimestamp = ll .Tail; uiRW.Write( ui, () => { ui.EditedTimestamp = lastTimestamp; }); }); r.Run <SettingsHolder>(settings => { settings.LastVisitedKeyLabel = uiRW.Read( hnUi, () => hnUi.ActiveKeyLabel); uiRW.Write( hnUi, () => { hnUi.ActiveKeyLabel = null; }); }); uiRW.Write( homeUi, () => { homeUi.Editing = true; }); }); }
public virtual T PreInvoke <T>( Action <T> act, params object[] dependencies) where T : class, IDisposable { var actor = this.illuminator.Illumine <T>(dependencies); act(actor); this.freedomHolder.Surge( new XLinkedListLot <IDisposable>( XLinkedList <IDisposable> .Create( new IDisposable[] { actor }))); return(actor); }
public virtual IEnumerable <T> Innovate <T>( Lot <T>[] lots, Func <T, BigInteger> valueChooser) { if (lots == null || lots.Length < 1) { yield break; } var enumerators = new XLinkedList <IEnumerator <T> >(); foreach (var lot in lots) { if (lot == null) { continue; } enumerators.AddTail(lot.GetEnumerator()); } while (enumerators.Head?.MoveNext() ?? false) { BigInteger leastValue = long.MaxValue; BigInteger maximalValue = 0; var leastItem = default(T); var maximalItem = default(T); foreach (var enumerator in Skip( enumerators, 1)) { enumerator.MoveNext(); var value = valueChooser(enumerator.Current); if (value < leastValue) { leastValue = value; leastItem = enumerator.Current; } if (value > maximalValue) { maximalValue = value; maximalItem = enumerator.Current; } } yield return(leastItem); yield return(maximalItem); } }
public void PushRange( IEnumerable <T> source) { Lot <T> lot = new XLinkedListLot <T>( XLinkedList <T> .Create( source)); var array = new T[lot.Count]; long counter = zero; foreach (var item in lot) { array[counter] = item; ++counter; } this.stack.PushRange(array); }
protected virtual int deepen( TreeNode <T> node, int currentDepth) { if (node.Nodes.Count < 1) { return(currentDepth); } ++currentDepth; var depths = new XLinkedList <int>(); foreach (var n in node.Nodes) { depths.AddTail(this.deepen(n, currentDepth)); } return(Max(depths)); }
public Lot <Action <T> > PeekComputations( BigInteger numberToPeek) { var ll = new XLinkedList <Action <T> >(); var enumerator = this.computations.GetEnumerator(); enumerator.MoveNext(); for (var i = 0; i < numberToPeek; ++i) { ll.AddTail(enumerator.Current); if (!enumerator.MoveNext()) { break; } } enumerator.Dispose(); return(new XLinkedListLot <Action <T> >(ll)); }
public virtual T Illumine <T>( Lot <object> dependencies) { var constructors = XLinkedList <ConstructorInfo> .Create( EH.OrderByDescending( typeof(T).GetConstructors(), ci => ci.GetParameters().Length)); var list = new List <object>(dependencies); foreach (var ctor in constructors) { var parameters = ctor.GetParameters(); var valuesNeeded = new List <object>(list.Count); foreach (var parameter in parameters) { for (var i = 0; i < list.Count; ++i) { if (!parameter.ParameterType.IsInstanceOfType(list[i])) { continue; } valuesNeeded.Add(list[i]); list.Remove(list[i]); break; } } if (valuesNeeded.Count == parameters.Length) { list = valuesNeeded; break; } // if the objects don't line up with this constructor, start over with the next one list = new List <object>(dependencies); valuesNeeded.Clear(); } return((T)Activator.CreateInstance(typeof(T), list.ToArray())); }
public virtual TUi ReadUi <TUi, TPresenter>( string uiName = null, string presenterName = null) where TUi : Ui where TPresenter : Presenter { const byte one = 1; ICollection <UiHolder> matches; lock (this.locker) { matches = XLinkedList <UiHolder> .Create( Where( this.uiHolders, ui => ui.Content is TUi)); } if (matches.Count < one) { return(default);
public virtual Lot <T>[] Slice <T>( IEnumerable <T> finiteSource, Lot <int> slicePoints) { const byte zero = 0, one = 1; if (finiteSource == null) { return(new Lot <T> [zero]); } if (slicePoints == null || slicePoints.Count < one) { return(new Lot <T> [zero]); } ICollection <T> remainingItems = XLinkedList <T> .Create(finiteSource); var array = new Lot <T> [slicePoints.Count]; int counter = zero; foreach (var slicePoint in slicePoints) { var sequence = EH.Take( remainingItems, slicePoint); array[counter] = new XLinkedListLot <T>( XLinkedList <T> .Create( sequence)); ++counter; remainingItems = XLinkedList <T> .Create( EH.Skip( remainingItems, slicePoint)); } return(array); }
public void Otherwise_returns_time_worked_for_the_week() { var w = this.web; w.Unregister <DateCalculator>(); w.RegisterDependency( A.Fake <DateCalculator>()); w.Run <DateCalculator>(fakeDater => { A .CallTo(() => fakeDater.StartOfWeek()) .Returns(new DateTime( 2020, 11, 24)); A .CallTo(() => fakeDater.EndOfWeek()) .Returns(new DateTime( 2020, 11, 25)); }); var allTimes = XLinkedList <DateTime> .Create(new[] { new DateTime(2020, 11, 24, 7, 0, 0), new DateTime(2020, 11, 24, 1, 45, 0), new DateTime(2020, 11, 24, 2, 40, 0), new DateTime(2020, 11, 24, 5, 40, 0), }); A .CallTo(() => this.reader.ReadAll()) .Returns(allTimes); Assert.Equal( new TimeSpan(0, 2, 15, 0), this.calc.TimeWorkedThisWeek()); }
public virtual bool Judge( Lot <T> lot, Action <T> learn) { var reflection = new Reflection <T>(lot, this.absolution); var hashCodes = new XLinkedList <int>(); var isKnowledge = true; foreach (var item in reflection.Reflect(learn)) { var hashCode = item.GetHashCode(); if (hashCodes.Contains(hashCode)) { isKnowledge = false; break; } hashCodes.AddTail(item.GetHashCode()); } return(isKnowledge); }
public virtual Lot <object> Process( IEnumerable <object> references) { var ll = new XLinkedList <object>(); var lld = new XLinkedList <IDisposable>(); foreach (var reference in references) { if (reference is IDisposable) { lld.AddTail((IDisposable)reference); continue; } ll.AddTail(reference); } // ReSharper disable once ImpureMethodCallOnReadonlyValueField this.martyr.BringToGod(new XLinkedListLot <IDisposable>(lld)); return(new XLinkedListLot <object>(ll)); }
public virtual Tuple <LiberatedObject, LiberatedObject> Slice( LiberatedObject anObject, int slicePoint) { if (anObject == null) { return(Tuple.Create <LiberatedObject, LiberatedObject>( null, null)); } var dc = anObject.DependencyCount; if (slicePoint > dc) { return(Tuple.Create <LiberatedObject, LiberatedObject>( null, null)); } var oneDeps = new XLinkedList <object>(); for (var i = 0; i < slicePoint; ++i) { oneDeps.AddTail(anObject[i]); } var twoDeps = new XLinkedList <object>(); for (var i = slicePoint; i < dc; ++i) { twoDeps.AddTail(anObject[i]); } return(Tuple.Create( new LiberatedObject(oneDeps), new LiberatedObject(twoDeps))); }
public virtual Lot <T> Reorder( IEnumerable <T> source, int startIndex, int take) { var ll = XLinkedList <T> .Create(source); var rotated = this.rotator.Rotate( ll, startIndex, false); var start = Take(rotated, take); var next = Take(ll, startIndex); var end = Empty <T>(); if (ll.Count > startIndex + take) { end = Skip(ll, startIndex + take); } return(this.connector.Connect(start, next, end)); }
public virtual Lot <T> Darken <T>( IEnumerable <T> source, BigInteger limiter) { var hashCodes = new XLinkedList <int>(); // hash codes should be longs var darkenedCollection = new XLinkedList <T>(); foreach (var item in source) { var hashCode = item.GetHashCode(); if (Any( hashCodes, hc => Math.Abs(hashCode - hc) < limiter)) { continue; } hashCodes.AddTail(hashCode); darkenedCollection.AddTail(item); } return(new XLinkedListLot <T>( darkenedCollection)); }
public virtual void Order(Tree <T> tree) { this.currentTree = new XLinkedListLot <T>( XLinkedList <T> .Create(Reverse( tree))); }
public virtual TimeSpan TimeWorked( DateTime beginning, DateTime end) { var r = this.runner; var allTimes = this.allTimes(); var timeWorked = TimeSpan.Zero; var timesInRange = new XLinkedList <DateTime>(); long timeCounter = 0; foreach (var time in allTimes) { if (time < beginning) { ++timeCounter; if (timeCounter < allTimes.Count) { continue; } goto checkIfClockedInBeforeFirst; } if (time > end) { if (timesInRange.Count < 1 && timeCounter % 2 == 1) { // clocked in at beginning timesInRange.AddTail(beginning); } if (timesInRange.Count % 2 == 1) { // clocked in at end timesInRange.AddTail(end); } break; } checkIfClockedInBeforeFirst: if (timesInRange.Count < 1 && timeCounter % 2 == 1) { // clocked in at start of range timesInRange.AddHead(beginning); } if (timeCounter >= allTimes.Count) { break; } timesInRange.AddTail(time); } var e = ((ICollection <DateTime>)timesInRange) .GetEnumerator(); while (e?.MoveNext() ?? false) { var inTime = e.Current; if (!e.MoveNext()) { var now = DateTime.Now; r?.Run <TimeProvider>(provider => { now = provider.Now(); }); if (end.Date > now) { if (inTime < now) { timeWorked += now - inTime; } break; } timeWorked += end.Date - inTime; break; } var outTime = e.Current; timeWorked += outTime - inTime; } e.Dispose(); return(timeWorked); }
public virtual bool ConvertToSingleFile() { var md = this.mainDirectory; try { if (!Directory.Exists(md)) { Directory.CreateDirectory(md); return(true); } } catch { return(false); } try { var files = Directory.GetFiles(md); if (files.Length == 1 && files[0].Contains(DataFileName)) { return(true); } } catch { return(false); } ICollection <string> times = new XLinkedList <string>(); try { foreach (var file in Directory.GetFiles(md)) { foreach (var line in File.ReadAllLines(file)) { times.Add(line); } } } catch { return(false); } try { File.WriteAllLines( Path.Combine(md, DataFileName), EnumerableHelpers.ToArray( times)); foreach (var file in Directory.GetFiles(md)) { if (file.Contains(DataFileName)) { continue; } File.Delete(file); } } catch { return(false); } return(true); }
public virtual void Handle( TimestampsUi ui, HomeNavUi homeNavUi, StatisticsUi statsUi) { var r = this.runner; const byte one = 1; r?.Run <UiReaderWriter>(uiRW => { uiRW.Write( homeNavUi, () => { homeNavUi.ActiveKeyLabel = NavKeyLabels.Timestamps; }); }); var showCurrent = true; r?.Run <SettingsHolder>(settings => { showCurrent = settings.ShowCurrent; }); var now = DateTime.Now; var start = DateTime.Today; r?.Run <TimeProvider>(provider => { now = provider.Now(); start = now.Date; }); var end = start.AddDays(one); if (showCurrent) { r?.Run <DateCalculator>( calc => { start = calc.StartOfWeek(); end = calc.EndOfWeek().AddDays(one); }); goto findAndSetTimesInRange; } r?.Run <UiReaderWriter>(uiRW => { start = uiRW.Read( statsUi, () => statsUi.StartDate); end = uiRW.Read( statsUi, () => statsUi.EndDate) .AddDays(1); }); findAndSetTimesInRange: r?.Run < TimestampReader, Lotter, EnumerableSplitter, UiReaderWriter>( (reader, lotter, splitter, uiRW) => { var allTimes = reader.ReadAll(); var timesInRange = new XLinkedList <DateTime>(); foreach (var time in allTimes) { if (time < start) { continue; } if (time > end) { continue; } timesInRange.AddTail(time); } bool firstIn, lastIn; if (timesInRange.Count < one) { firstIn = false; lastIn = false; goto checkAdd; } firstIn = this.isInTime( timesInRange.Head); lastIn = this.isInTime( timesInRange.Tail); checkAdd: var inNow = allTimes.Count % two == one; var oddTimesInRange = timesInRange.Count % two == one; if (oddTimesInRange) { if (inNow && firstIn) { if (now > end.AddDays(one)) { // was clocked in at end of range timesInRange.AddTail(end); } // clocked in currently, do nothing goto afterCheckClockedIn; } if (firstIn) { // clocked in at end of week timesInRange.AddTail(end.Date); goto afterCheckClockedIn; } // clocked out now but was clocked in at start of week timesInRange.AddHead(start.Date); goto afterCheckClockedIn; } if (timesInRange.Count > zero) { if (!firstIn) { timesInRange.AddHead(start.Date); } if (lastIn && end < now) { timesInRange.AddTail(end.Date); } } afterCheckClockedIn: var splitTimesThisWeek = splitter.Split( timesInRange, two); var inTimes = splitTimesThisWeek[zero]; var uiTimesIn = lotter.Materialize( EnumerableHelpers.Select( inTimes, this.formatTimestamp)); uiRW.Write( ui, () => { ui.InTimes = uiTimesIn; }); var outTimes = splitTimesThisWeek[one]; var uiTimesOut = lotter.Materialize( EnumerableHelpers.Select( outTimes, this.formatTimestamp)); uiRW.Write( ui, () => { ui.OutTimes = uiTimesOut; }); r.Run <EnumerableSplicer>( splicer => { var splicedTimes = splicer.Splice( new[] { inTimes, outTimes }); short indexer = zero; DateTime currentInTime = default,