public void DescribeCandidateProcesses(IList<IProcessInfo> candidates, ConsoleLog console) { var byArchitecture = candidates.ToLookup(c => c.Architecture); var self = ProcessArchitecture.FromCurrentProcess(); if(self is ProcessArchitecture.x86) { if(!x86Thunk.Bootstrap.WasUsed) { // Native x86. Write out everything. WriteProcessList(candidates, console); } else { // Write out only matching processes. WriteProcessList(byArchitecture[self].ToList(), console); } } else { WriteProcessList(byArchitecture[self].ToList(), console); if(byArchitecture[new ProcessArchitecture.x86()].Any()) { // Go to 32-bit and render the rest of the process information. Bootstrap.RecurseInto32BitProcess(); } } }
private IList <Player> GetPlayers(IList <SimplifiedPlayer> members) { var wr = new Wrapper(ApiKey); var membersLookup = members?.ToLookup(k => k.tag, v => v); var players = wr.GetPlayer(membersLookup?.Select(t => t.Key).ToArray()); return(players); }
public IEnumerable<IssueMatch> Match (IList<ActionSummary> summaries, IList<CodeAction> realActions) { var summaryLookup = summaries.ToLookup (summary => summary.Region); foreach (var action in realActions) { if (summaryLookup.Contains (action.DocumentRegion)) { yield return new IssueMatch { Action = action, Summary = summaryLookup[action.DocumentRegion].First () }; } } }
public void GuardarRedes(IList<Resultado> lista, string archivo, IList<FichaIndicadores> fichas) { var map = fichas.ToDictionary(x => x.Nombre); var grupos = lista.ToLookup(x => x.Tipo_item); using (var pck = new ExcelPackage(new FileInfo(archivo))) { try { foreach (var grupo in grupos) { if (!map.ContainsKey(grupo.Key)) continue; Ficha = map[grupo.Key]; CrearHoja(grupo.ToList(), Ficha.Nombre, pck); } pck.Save(); } catch (Exception ex) { AppNotifier.Print("Error " + ex.Message, ex); } } }
private IList <DataRowDetails> SumMs1Transitions(IList <DataRowDetails> dataRows) { var dataRowsByReplicateIndexAndTransitionGroup = dataRows.ToLookup(row => new Tuple <int, IdentityPath>(row.ReplicateIndex, row.IdentityPath.GetPathTo((int)SrmDocument.Level.TransitionGroups))); var newDataRows = new List <DataRowDetails>(); foreach (var grouping in dataRowsByReplicateIndexAndTransitionGroup) { DataRowDetails ms1DataRow = null; var transitionGroup = (TransitionGroupDocNode)SrmDocument.FindNode(grouping.Key.Item2); foreach (var dataRow in grouping) { var transition = (TransitionDocNode)transitionGroup.FindNode(dataRow.IdentityPath.Child); if (transition.IsMs1) { if (ms1DataRow == null) { ms1DataRow = new DataRowDetails() { IdentityPath = grouping.Key.Item2, BioReplicate = dataRow.BioReplicate, Control = dataRow.Control, ReplicateIndex = dataRow.ReplicateIndex }; } ms1DataRow.Intensity += dataRow.Intensity; ms1DataRow.Denominator += dataRow.Denominator; } else { newDataRows.Add(dataRow); } } if (ms1DataRow != null) { newDataRows.Add(ms1DataRow); } } return(newDataRows); }
protected IEnumerable <UM_Resource> FullHierarchyTraversal(IList <UM_Resource> resources, IList <UM_Resource> allResources) { var resourcesDict = allResources.ToDictionary(n => n.ID); var resourcesLp = allResources.ToLookup(n => n.ParentID.GetValueOrDefault()); foreach (var item in resources) { yield return(item); foreach (var parent in GetAllParents(item, resourcesDict)) { yield return(parent); } foreach (var child in GetAllChildren(item, resourcesLp)) { yield return(child); } } }
public void UpdateLabels(ISession session) { String tagsNames; NameValueCollection labelsByProperty = this.MyFetcher.GetLabels(); IList <LabelEntity> databaseLabels = session.CreateCriteria <LabelEntity>() .Add(Restrictions.Eq("MailAccountEntity", this.Entity)) .Add(Restrictions.Eq("Active", true)) .List <LabelEntity>(); this.RegisterLabel(labelsByProperty["INBOX"], session, databaseLabels, "Inbox"); this.RegisterLabel(labelsByProperty["All"], session, databaseLabels, "All"); this.RegisterLabel(labelsByProperty["Trash"], session, databaseLabels, "Trash"); this.RegisterLabel(labelsByProperty["Junk"], session, databaseLabels, "Junk"); this.RegisterLabel(labelsByProperty["Important"], session, databaseLabels, "Important"); this.RegisterLabel(labelsByProperty["Sent"], session, databaseLabels, "Sent"); this.RegisterLabel(labelsByProperty["Flagged"], session, databaseLabels, "Flagged"); this.RegisterLabel(labelsByProperty["Drafts"], session, databaseLabels, "Drafts"); tagsNames = labelsByProperty["Tags"]; if (tagsNames != null) { IList <String> labelsName = tagsNames.Split(new String[] { "," }, StringSplitOptions.RemoveEmptyEntries); labelsName = labelsName.Where(x => !x.Contains("[Gmail]/")).ToList(); //filtrar otros labels de Gmail foreach (String existingLabel in labelsName) { this.RegisterLabel(existingLabel, session, databaseLabels); } //eliminar labels que no esten en Gmail var namesLookUp = labelsName.ToLookup(x => x); var removedLabels = databaseLabels.Where(x => x.SystemName == null && !namesLookUp.Contains(x.Name)); foreach (LabelEntity removedLabel in removedLabels) { Label label = new Label(removedLabel); label.Delete(session); } } this.SetFetcherLabels(session); }
public IList<Result> Judge(IList<IPlayer> playerList) { if (playerList == null) { throw new ArgumentNullException("player is missing"); } if (playerList.Count < 1) { throw new ArgumentException("MajorityDecision need one person or more."); } var handLookup = playerList.ToLookup(player => player.ChoosedHand); if (handLookup.Count == 1) { return playerList.Map(player => new Result(player, ResultType.Draw)); } var maxCount = handLookup.Max(hand => handLookup[hand.Key].Count()); if (handLookup.Count(group => group.Count() == maxCount) > 1) { return playerList.Map(player => new Result(player, ResultType.Draw)); } var winHand = handLookup.First(group => group.Count() == maxCount).Key; return playerList.Map(player => new Result(player, player.ChoosedHand.Equals(winHand) ? ResultType.Win : ResultType.Lose)); }
private IList <ItemKey> DetermineKeysNotFound() { IList <ItemKey> keysFound = KeysFound; if (keysFound.IsNullOrEmpty()) { return(KeysRequested); } if (keysFound.Count == KeysRequested.Count) { return(null); } ILookup <string, ItemKey> foundKeysLookupTable = keysFound.ToLookup(key => key.ID); return(( from key in KeysRequested where !(foundKeysLookupTable.Contains(key.ID)) select key ).ToArray()); }
public void ApplyPendingDownloadIncrements(IList <LucenePackage> increments, ISession <LucenePackage> session) { if (increments.Count == 0) { return; } var byId = increments.ToLookup(p => p.Id); foreach (var grouping in byId) { var packageId = grouping.Key; var packages = from p in session.Query() where p.Id == packageId select p; var byVersion = grouping.ToLookup(p => p.Version); foreach (var lucenePackage in packages) { lucenePackage.DownloadCount += grouping.Count(); lucenePackage.VersionDownloadCount += byVersion[lucenePackage.Version].Count(); } } }
/// <summary> /// create a hashtable of start->list of tuples that start there /// put all tuples in a queue of tupleSets /// set the longestTupleSet to the first tuple /// while the queue is not empty /// take tupleSet from the queue /// if any tuples start where the tupleSet ends /// foreach tuple that starts where the tupleSet ends /// enqueue new tupleSet of tupleSet + tuple /// continue /// /// if tupleSet is longer than longestTupleSet /// replace longestTupleSet with tupleSet /// /// return longestTupleSet /// </summary> /// <param name = "input"></param> /// <returns></returns> public static IList<Pair<int, int>> FindLongestNonOverlappingRangeSet(IList<Pair<int, int>> input) { var rangeStarts = input.ToLookup(x => x.First, x => x); var adjacentTuples = new Queue<List<Pair<int, int>>>( input.Select(x => new List<Pair<int, int>> { x })); var longest = new List<Pair<int, int>> { input[0] }; int longestLength = input[0].Second - input[0].First; while (adjacentTuples.Count > 0) { var tupleSet = adjacentTuples.Dequeue(); var last = tupleSet.Last(); int end = last.First + last.Second; var sameStart = rangeStarts[end]; if (sameStart.Any()) { foreach (var nextTuple in sameStart) { adjacentTuples.Enqueue(tupleSet.Concat(new[] { nextTuple }).ToList()); } continue; } int length = end - tupleSet.First().First; if (length > longestLength) { longestLength = length; longest = tupleSet; } } return longest; }
public static void SimpleLookup() { IList <string> list = GetStringList(); //Sets KeyValue pair based on the string length. ILookup <int, string> lookup = list.ToLookup(i => i.Length); Console.WriteLine(); Console.WriteLine("String length=7"); //Iterates only string length having 7. foreach (string temp in lookup[7]) { Console.WriteLine(temp); } Console.WriteLine("String length=9"); //Iterates only string length having 9. foreach (string temp in lookup[9]) { Console.WriteLine(temp); } }
public static IEnumerable <TreeNode <T, TKey> > ToTree <T, TKey>( this IList <T> collection, Func <T, TKey> itemIdSelector, Func <T, TKey> parentIdSelector) { var rootNodes = new List <TreeNode <T, TKey> >(); var collectionHash = collection.ToLookup(parentIdSelector); //find root nodes var parentIds = collection.Select(parentIdSelector); var itemIds = collection.Select(itemIdSelector); var rootIds = parentIds.Except(itemIds); foreach (var rootId in rootIds) { rootNodes.AddRange( GetTreeNodes( itemIdSelector, collectionHash, rootId) ); } return(rootNodes); }
public void AddSecurityList(ISession session, IList <Entities.Security> securityList) { IList <Entities.Security> securityListFromDb = securityRepository.GetSecurityListByRequestDate(session, DateTime.Today); IDictionary <string, Entities.Security> securityFromDbDictionary = securityListFromDb.ToDictionary(s => s.Symbol?.ToUpperInvariant()); ILookup <string, Entities.Security> securityFromRequestDictionary = securityList.ToLookup(s => s.Symbol?.ToUpperInvariant()); IList <string> securityFromRequestKeys = securityFromRequestDictionary.Select(x => x.Key).ToList(); IList <string> newSymbolList = securityFromRequestKeys.Except(securityFromDbDictionary.Keys).ToList(); using (var ssession = dbSessionFactory.OpenStatelessSession()) using (var transaction = ssession.BeginTransaction()) { foreach (string symbol in newSymbolList) { Entities.Security security = securityFromRequestDictionary[symbol].FirstOrDefault(); securityRepository.Insert(ssession, security); } transaction.Commit(); } }
public void ApplyPendingDownloadIncrements(IList<LucenePackage> increments, ISession<LucenePackage> session) { if (increments.Count == 0) return; var byId = increments.ToLookup(p => p.Id); foreach (var grouping in byId) { var packageId = grouping.Key; var packages = from p in session.Query() where p.Id == packageId select p; var byVersion = grouping.ToLookup(p => p.Version); foreach (var lucenePackage in packages) { lucenePackage.DownloadCount += grouping.Count(); lucenePackage.VersionDownloadCount += byVersion[lucenePackage.Version].Count(); } } }
public static ILookup <TKey, TValue> ToLookup <TKey, TValue>( this IList <KeyValuePair <TKey, TValue> > source) { return(source.ToLookup(x => x.Key, x => x.Value)); }
public static IList<AlbumTarget> FromListAndTargets(IList<Track> iTracks, IList<Artist> Artists, string AlbumName, string itGenre = null, int? tYear = null) { var res = iTracks.ToLookup(t => t.RawAlbum).ToLookup(a => new AlbumTarget(Artists ?? a.Key.RawArtists, AlbumName ?? a.Key.Name, itGenre, tYear)); return res.Apply(g => g.Key.OrderedTrack = g.Select((gg) => new OriginedGroupedTrack(gg.Key, gg.ToList(), g.Key)).ToList()).Select(g => g.Key).ToList(); }
public void Save(Stream hpiStream, Stream hpbStream, IList <IArchiveFileInfo> files) { var sjis = Encoding.GetEncoding("SJIS"); var hash = new SimpleHash(0x25); using var hpiBw = new BinaryWriterX(hpiStream); // Calculate offsets var fileOffset = 0; var hashOffset = HeaderSize; var entryOffset = hashOffset + HashSlotCount_ * HashEntrySize; var stringOffset = entryOffset + files.Count * FileEntrySize; // Group files var fileLookup = files.ToLookup(x => hash.ComputeValue(x.FilePath.ToRelative().FullName, sjis) % HashSlotCount_); // Write files and strings hpiStream.Position = stringOffset; hpbStream.Position = fileOffset; foreach (var file in files.Cast <HpiHpbArchiveFileInfo>().OrderBy(x => x.FilePath, new SlashFirstStringComparer())) { fileOffset = (int)hpbStream.Position; var nameOffset = (int)hpiStream.Position; var writtenSize = file.SaveFileData(hpbStream); hpiBw.WriteString(file.FilePath.ToRelative().FullName, sjis, false); file.Entry.offset = fileOffset; file.Entry.stringOffset = nameOffset - stringOffset; file.Entry.compSize = (int)writtenSize; file.Entry.decompSize = file.UsesCompression ? (int)file.FileSize : 0; } // Write entries var hashes = new List <HpiHashEntry>(); hpiStream.Position = entryOffset; for (uint i = 0, offset = 0; i < HashSlotCount_; i++) { var hashEntry = new HpiHashEntry { entryOffset = (short)offset, entryCount = (short)fileLookup[i].Count() }; hashes.Add(hashEntry); offset += (uint)hashEntry.entryCount; foreach (var file in fileLookup[i].Cast <HpiHpbArchiveFileInfo>()) { hpiBw.WriteType(file.Entry); } } // Write hash entries hpiStream.Position = hashOffset; hpiBw.WriteMultiple(hashes); // Write header hpiStream.Position = 0; hpiBw.WriteType(new HpiHeader { hashCount = (short)hashes.Count, entryCount = files.Count }); }
public void PostMoveAnalytics() { var playersByLocation = players.ToLookup(x => x.GetPosition()); foreach (var meetingPlayers in playersByLocation.Where(x => playersByLocation.Any(y => y.Key == x.Key + 1))) { foreach (var meetingPlayer in meetingPlayers) { if (meetingPlayer.GetDirection() < 0) { continue; } foreach (var player in playersByLocation .Where(y => y.Key == meetingPlayers.Key + 1) .SelectMany(x => x) .Where(x => x.GetDirection() < 0)) { stats.AddPlayerMeet(PlayerMeet.Create( meetingPlayers.Key, meetingPlayer, meetingPlayers.Key + 1, player)); } } } foreach (var meetingPlayers in playersByLocation.Where(x => playersByLocation.Any(y => y.Key == x.Key - 1))) { foreach (var meetingPlayer in meetingPlayers) { if (meetingPlayer.GetDirection() > 0) { continue; } foreach (var player in playersByLocation .Where(y => y.Key == meetingPlayers.Key - 1) .SelectMany(x => x) .Where(x => x.GetDirection() > 0)) { stats.AddPlayerMeet(PlayerMeet.Create( meetingPlayers.Key, meetingPlayer, meetingPlayers.Key - 1, player)); } } } foreach (var passingPlayers in playersByLocation.Where(x => playersByLocation.Any(y => y.Key == x.Key - 1))) { foreach (var meetingPlayer in passingPlayers) { if (meetingPlayer.GetDirection() < 0) { continue; } foreach (var player in playersByLocation .Where(y => y.Key == passingPlayers.Key - 1) .SelectMany(x => x) .Where(x => x.GetDirection() < 0)) { stats.AddPlayerPass(PlayerPass.Create( passingPlayers.Key, meetingPlayer, passingPlayers.Key - 1, player)); } } } foreach (var passingPlayers in playersByLocation.Where(x => playersByLocation.Any(y => y.Key == x.Key + 1))) { foreach (var meetingPlayer in passingPlayers) { if (meetingPlayer.GetDirection() > 0) { continue; } foreach (var player in playersByLocation .Where(y => y.Key == passingPlayers.Key + 1) .SelectMany(x => x) .Where(x => x.GetDirection() > 0)) { stats.AddPlayerPass(PlayerPass.Create( passingPlayers.Key, meetingPlayer, passingPlayers.Key + 1, player)); } } } foreach (var passingPlayers in playersByLocation.Where(x => x.Count() > 1)) { foreach (var meetingPlayer in passingPlayers) { foreach (var player in playersByLocation .SelectMany(x => x)) { stats.AddPlayerPass(PlayerPass.Create( passingPlayers.Key, meetingPlayer, passingPlayers.Key + 1, player)); } } } foreach (var playersNotOnBoard in playersByLocation.Where(x => !IsOnBoard(x.Key))) { foreach (var player in playersNotOnBoard) { players.Remove(player); } } }
public ILookup <string, string> AsILookup() { return(errorList.ToLookup(_ => _.Key, _ => _.Value)); }
public IEnumerable <string> Invoke(IList <string> input) { // I've kept this method simple but I also chose include sanity checks and a minor edge case so that you know what I've considered. // Sanity check input. Would normally do this kind of thing with Code Contracts. // Could have combined all 3 checks to yield break rather than raising an exception. // I do like the explicit nature of raising exceptions though and in prod code would define a more useful exception type. if (input == null || input.Any() == false) { throw new Exception("You must pass a non-empty, non-null parameter to the Parse method."); } if (input.Count < 3) { yield break; } // Store the input in a lookup with word length as the key. Lookup is more performant than some other solutions such as doing a Where on the input. var lookup = input.ToLookup(x => x.Length); // Using a hashset for constant time lookup when doing .Contains() (O(1)). // Could have used a list but since we've got a base count of items > 5, HashSet is probably more performant. var possibleWords = new HashSet <string>(lookup[6]); // This is the expanded non-linq version. I've included two Linq versions below for comparison. // I'd use the Linq version in production code but it's sometimes nice to see it written long(er) form in a test too. // I could have also looped over the 6 char words instead of all of them and output based on whether any combination makes the current word. foreach (var word in input) { // Copy word variable so we don't access foreach variable in closure. var safeWord = word; // Get all the right hand segments that would create a combined word + part length equal to 6. var possParts = lookup[6 - word.Length].ToList(); // This one is a bit of an edge case but I thought I'd include it since I'd written the test for it already. // We want to make sure that a segment isn't appended to itself to form a combination that's also a valid word // whilst at the same time, making sure that if a segment apears twice, and its combination is a valid word, it passes. var indexOfCurrentWord = possParts.FindIndex(x => x == safeWord); if (indexOfCurrentWord >= 0) { possParts.RemoveAt(indexOfCurrentWord); } foreach (var part in possParts) { var comb = word + part; if (possibleWords.Contains(comb)) { yield return(comb); } } } /* * LINQ variations of the foreach above: * 1) return from word in input let possParts = lookup[6 - word.Length] from part in possParts select word + part into comb where possibleWords.Contains(comb) select comb; * * 2) return input * .SelectMany(w => lookup[6 - w.Length], (w, y) => new { Value = w + y }) * .Where(x => possibleWords.Contains(x.Value)) * .Select(x => x.Value); */ }
private void RebuildIndexes() { _indexes = _lookups.ToDictionary( lookup => lookup.ToString(), lookup => _items.ToLookup(lookup.Compile())); }
public static Tree <T> ToTree <T>(this IList <T> items, Func <T, T, bool> parentSelector) { var lookup = items.ToLookup(item => items.FirstOrDefault(parent => parentSelector(parent, item)), child => child); return(Tree <T> .FromLookup(lookup)); }
private async Task UploadLocalChanges() { this.OnSyncProgress(new SyncProgressEventArgs("Get local changes...")); IList <DirtyEntity> allDirtyItems = await siaqodbMobile.LoadAllAsync <DirtyEntity>(); ILookup <string, DirtyEntity> lookup = allDirtyItems.ToLookup(a => a.EntityType); this.OnSyncProgress(new SyncProgressEventArgs("Prepare uploads...")); foreach (var item in lookup) { IEnumerable <DirtyEntity> entities = lookup[item.Key]; Dictionary <int, Tuple <object, DirtyEntity> > inserts = new Dictionary <int, Tuple <object, DirtyEntity> >(); Dictionary <int, Tuple <object, DirtyEntity> > updates = new Dictionary <int, Tuple <object, DirtyEntity> >(); Dictionary <int, Tuple <object, DirtyEntity> > deletes = new Dictionary <int, Tuple <object, DirtyEntity> >(); Type type = ReflectionHelper.GetTypeByDiscoveringName(entities.First <DirtyEntity>().EntityType); if (!this.SyncedTypes.ContainsKey(type)) { continue; } string tableName = this.SyncedTypes[type]; foreach (DirtyEntity en in entities) { if (en.DirtyOp == DirtyOperation.Deleted) { if (inserts.ContainsKey(en.EntityOID)) { siaqodbMobile.DeleteBase(inserts[en.EntityOID].Item1); siaqodbMobile.DeleteBase(en); inserts.Remove(en.EntityOID); continue; } else if (updates.ContainsKey(en.EntityOID)) { siaqodbMobile.DeleteBase(updates[en.EntityOID].Item1); updates.Remove(en.EntityOID); } } else { if (deletes.ContainsKey(en.EntityOID) || inserts.ContainsKey(en.EntityOID) || updates.ContainsKey(en.EntityOID)) { siaqodbMobile.DeleteBase(en); continue; } } object entityFromDB = _bs._lobjby(siaqodbMobile, type, en.EntityOID); if (en.DirtyOp == DirtyOperation.Inserted) { inserts.Add(en.EntityOID, new Tuple <object, DirtyEntity>(entityFromDB, en)); } else if (en.DirtyOp == DirtyOperation.Updated) { updates.Add(en.EntityOID, new Tuple <object, DirtyEntity>(entityFromDB, en)); } else if (en.DirtyOp == DirtyOperation.Deleted) { deletes.Add(en.EntityOID, new Tuple <object, DirtyEntity>(entityFromDB, en)); } } this.OnSyncProgress(new SyncProgressEventArgs("Start upload changes...")); IMobileServiceTable table = MobileService.GetTable(tableName); table.SystemProperties |= MobileServiceSystemProperties.All; this.OnSyncProgress(new SyncProgressEventArgs("Start upload inserts...")); await UploadInserts(table, inserts); this.OnSyncProgress(new SyncProgressEventArgs("Inserts uploads finished...")); this.OnSyncProgress(new SyncProgressEventArgs("Start upload updates...")); await UploadUpdates(table, updates); this.OnSyncProgress(new SyncProgressEventArgs("Updates uploads finished...")); this.OnSyncProgress(new SyncProgressEventArgs("Start upload deletes...")); await UploadDeletes(table, deletes); this.OnSyncProgress(new SyncProgressEventArgs("Deletes uploads finished...")); siaqodbMobile.Flush(); } siaqodbMobile.DropType <DirtyEntity>(); this.OnSyncProgress(new SyncProgressEventArgs("Uploads finsihed...")); }
private void WriteComments(IList <POComment> comments) { IOrderedEnumerable <IGrouping <POCommentKind, POComment> > commentLookup = comments.ToLookup(c => c.Kind).OrderBy(c => c.Key); foreach (IGrouping <POCommentKind, POComment> commentGroup in commentLookup) { foreach (POComment comment in commentGroup) { char commentKindToken; switch (comment.Kind) { case POCommentKind.Translator: commentKindToken = ' '; break; case POCommentKind.Extracted: commentKindToken = '.'; break; case POCommentKind.Reference: commentKindToken = ':'; break; case POCommentKind.Flags: commentKindToken = ','; break; case POCommentKind.PreviousValue: commentKindToken = '|'; break; default: throw new InvalidOperationException(); } _writer.WriteLine($"#{commentKindToken} {comment}"); } } }
public void Generate(string projectRoot, IList <ControllerDefinition> controllers) { var areaControllers = controllers.ToLookup(c => c.Area); // Processing controllers, generating partial and derived controller classes for R4Mvc var generatedControllers = new List <NamespaceDeclarationSyntax>(); foreach (var namespaceGroup in controllers.Where(c => c.Namespace != null).GroupBy(c => c.Namespace).OrderBy(c => c.Key)) { var namespaceNode = NamespaceDeclaration(ParseName(namespaceGroup.Key)); foreach (var controller in namespaceGroup.OrderBy(c => c.Name)) { namespaceNode = namespaceNode.AddMembers( _controllerGenerator.GeneratePartialController(controller), _controllerGenerator.GenerateR4Controller(controller)); // If SplitIntoMultipleFiles is set, store the generated classes alongside the controller files. if (_settings.SplitIntoMultipleFiles) { var controllerFile = NewCompilationUnit() .AddMembers(namespaceNode); CompleteAndWriteFile(controllerFile, controller.GetFilePath().TrimEnd(".cs") + ".generated.cs"); namespaceNode = NamespaceDeclaration(ParseName(namespaceGroup.Key)); } } // If SplitIntoMultipleFiles is NOT set, bundle them all in R4Mvc if (!_settings.SplitIntoMultipleFiles) { generatedControllers.Add(namespaceNode); } } // R4MVC namespace used for the areas and Dummy class var r4Namespace = NamespaceDeclaration(ParseName(_settings.R4MvcNamespace)) // add the dummy class using in the derived controller partial class .WithDummyClass() .AddMembers(CreateViewOnlyControllerClasses(controllers).ToArray <MemberDeclarationSyntax>()) .AddMembers(CreateAreaClasses(areaControllers).ToArray <MemberDeclarationSyntax>()); // create static MVC class and add the area and controller fields var mvcStaticClass = ClassDeclaration(_settings.HelpersPrefix) .WithModifiers(SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword, SyntaxKind.PartialKeyword) .WithGeneratedNonUserCodeAttributes(); foreach (var area in areaControllers.Where(a => !string.IsNullOrEmpty(a.Key)).OrderBy(a => a.Key)) { mvcStaticClass = mvcStaticClass.WithStaticFieldBackedProperty(area.First().AreaKey, $"{_settings.R4MvcNamespace}.{area.Key}AreaClass", SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword); } foreach (var controller in areaControllers[string.Empty].OrderBy(c => c.Namespace == null).ThenBy(c => c.Name)) { mvcStaticClass = mvcStaticClass.AddMembers( SyntaxNodeHelpers.CreateFieldWithDefaultInitializer( controller.Name, controller.FullyQualifiedGeneratedName, controller.FullyQualifiedR4ClassName ?? controller.FullyQualifiedGeneratedName, SyntaxKind.PublicKeyword, SyntaxKind.StaticKeyword, SyntaxKind.ReadOnlyKeyword)); } // Generate a list of all static files from the wwwroot path var staticFileNode = _staticFileGenerator.GenerateStaticFiles(projectRoot); var r4mvcNode = NewCompilationUnit() .AddMembers( mvcStaticClass, r4Namespace, staticFileNode, ActionResultClass(), JsonResultClass(), ContentResultClass(), RedirectResultClass(), RedirectToActionResultClass(), RedirectToRouteResultClass()) .AddMembers(generatedControllers.ToArray <MemberDeclarationSyntax>()); CompleteAndWriteFile(r4mvcNode, Path.Combine(projectRoot, R4MvcGeneratorService.R4MvcFileName)); }
public void ReplaceIndexersCalls(MethodDefinition method, IList<SliceParameters> slices) { var processor = method.Body.GetILProcessor(); var instructions = processor.Body.Instructions; var slicesLookup = slices.ToLookup(x => x.Definition); for (int offset = 0; offset < instructions.Count; offset++) { var instruction = instructions[offset]; if (!instruction.OpCode.IsCall()) continue; var methodReference = instruction.Operand as MethodReference; if (methodReference == null) continue; if (methodReference.Name != "get_Item" && methodReference.Name != "set_Item") continue; var objectToCall = instruction.TraceBack(methodReference, 0); var parameter = instruction.TraceBack(methodReference, -1); var slice = slicesLookup[objectToCall.Operand].FirstOrDefault(); if (slice == null) continue; var arraySliceType = ModuleDefinition.Import(typeof(ArraySlice<>)).MakeGenericInstanceType(slice.GenericArgument); var methodDefinition = methodReference.Resolve(); // FIXME: We know we cannot process if anything happens between the push of the array slice and the final operation. if (methodDefinition.IsGetter) { // Original GET: // 1 ldarg.s segment $ Push the object to call // = ldloc.1 $ Push the parameter // 2 callvirt instance !0 class ArraySegment.ArraySlice`1<float32>::get_Item(int32) // = stloc.s t $ Do whatever with the result of the GET call // Target GET: // 1 ldloc.s data $ Push the object to call // = ldloc.1 $ Push the parameter // 2 ldloc.s offset // 2 add $ Add the parameter (i) and the offset. // 2 ldelem.r4 $ Use standard ldelem with type to get the value from the array. // = stloc.s t $ Do whatever with the result of the GET call //HACK: We rewrite it to avoid killing the loop. objectToCall.OpCode = OpCodes.Ldloc; objectToCall.Operand = slice.ArrayVariable; processor.Replace(instruction, Instruction.Create(OpCodes.Ldelem_Any, slice.GenericArgument)); processor.InsertAfter(parameter, new[] { Instruction.Create( OpCodes.Ldloc, slice.OffsetVariable ), Instruction.Create( OpCodes.Add ) }); } else if (methodDefinition.IsSetter) { // Original SET: // 1 ldarg segment $ Push the object to call // = ldloc.0 $ Push the parameter // = ldc.r4 2 $ Push the value to set // 2 callvirt instance void class ArraySegment.ArraySlice`1<float32>::set_Item(int32, !0) // - nop $ Check if it even exists after SimplifyMacros in the collection. // Target SET // 1 ldloc data $ Push the array // = ldloc.0 $ Push the parameter // 2 ldloc offset // 2 add $ Add the parameter (i) and the offset. // = ldc.r4 2 $ Push the value to set. Use standard ldc with type and check if it is optimized afterwards. // 2 stelem $ Use standard stelem with type and check if it is optimized afterwards. //HACK: We rewrite it to avoid killing the loop. objectToCall.OpCode = OpCodes.Ldloc; objectToCall.Operand = slice.ArrayVariable; processor.Replace(instruction, Instruction.Create(OpCodes.Stelem_Any, slice.GenericArgument)); processor.InsertAfter(parameter, new[] { Instruction.Create( OpCodes.Ldloc, slice.OffsetVariable ), Instruction.Create( OpCodes.Add ) }); } else continue; } }
private void ResetCaches() { m_lookup = m_data.ToLookup(c => c.BcvRef.BBCCCVVV); m_uniqueCharacterAndDeliveries = null; m_uniqueDeliveries = null; }
private void TestToLookup() { var studentsGrouped = _studentList.ToLookup(s => s.Age).ToList(); PrintGrouping(studentsGrouped); }
public ILookup <string, Author> GroupByCountry(IReadOnlyList <string> countries) { var res = _authors.ToLookup(a => a.Country); return(res); }
public TraktSyncEpisodesResult SyncSeries() { _mediaPortalServices.GetLogger().Info("Trakt: start sync series"); ValidateAuthorization(); TraktSyncEpisodesResult syncEpisodesResult = new TraktSyncEpisodesResult(); TraktEpisodes traktEpisodes = _traktCache.RefreshSeriesCache(); IList <Episode> traktUnWatchedEpisodes = traktEpisodes.UnWatched; IList <EpisodeWatched> traktWatchedEpisodes = traktEpisodes.Watched; IList <EpisodeCollected> traktCollectedEpisodes = traktEpisodes.Collected; Guid[] types = { MediaAspect.ASPECT_ID, EpisodeAspect.ASPECT_ID, VideoAspect.ASPECT_ID, ImporterAspect.ASPECT_ID, ProviderResourceAspect.ASPECT_ID, ExternalIdentifierAspect.ASPECT_ID }; var contentDirectory = _mediaPortalServices.GetServerConnectionManager().ContentDirectory; if (contentDirectory == null) { throw new MediaLibraryNotConnectedException("ML not connected"); } Guid? userProfile = null; IUserManagement userProfileDataManagement = _mediaPortalServices.GetUserManagement(); if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser) { userProfile = userProfileDataManagement.CurrentUser.ProfileId; } #region Get data from local database IList <MediaItem> localEpisodes = contentDirectory.SearchAsync(new MediaItemQuery(types, null, null), true, userProfile, false).Result; if (localEpisodes.Any()) { syncEpisodesResult.CollectedInLibrary = localEpisodes.Count; _mediaPortalServices.GetLogger().Info("Trakt: found {0} total episodes in library", localEpisodes.Count); } List <MediaItem> localWatchedEpisodes = localEpisodes.Where(MediaItemAspectsUtl.IsWatched).ToList(); if (localWatchedEpisodes.Any()) { syncEpisodesResult.WatchedInLibrary = localWatchedEpisodes.Count; _mediaPortalServices.GetLogger().Info("Trakt: found {0} episodes watched in library", localWatchedEpisodes.Count); } #endregion #region Mark episodes as unwatched in local database _mediaPortalServices.GetLogger().Info("Trakt: start marking series episodes as unwatched in media library"); if (traktUnWatchedEpisodes.Any()) { // create a unique key to lookup and search for faster ILookup <string, MediaItem> localLookupEpisodes = localWatchedEpisodes.ToLookup(twe => CreateLookupKey(twe), twe => twe); foreach (var episode in traktUnWatchedEpisodes) { string tvdbKey = CreateLookupKey(episode); var watchedEpisode = localLookupEpisodes[tvdbKey].FirstOrDefault(); if (watchedEpisode != null) { _mediaPortalServices.GetLogger().Info( "Marking episode as unwatched in library, episode is not watched on trakt. Title = '{0}', Year = '{1}', Season = '{2}', Episode = '{3}', Show TVDb ID = '{4}', Show IMDb ID = '{5}'", episode.ShowTitle, episode.ShowYear.HasValue ? episode.ShowYear.ToString() : "<empty>", episode.Season, episode.Number, episode.ShowTvdbId.HasValue ? episode.ShowTvdbId.ToString() : "<empty>", episode.ShowImdbId ?? "<empty>"); if (_mediaPortalServices.MarkAsUnWatched(watchedEpisode).Result) { syncEpisodesResult.MarkedAsUnWatchedInLibrary++; } // update watched episodes localWatchedEpisodes.Remove(watchedEpisode); } } } #endregion #region Mark episodes as watched in local database _mediaPortalServices.GetLogger().Info("Trakt: start marking series episodes as watched in media library"); if (traktWatchedEpisodes.Any()) { // create a unique key to lookup and search for faster ILookup <string, EpisodeWatched> onlineEpisodes = traktWatchedEpisodes.ToLookup(twe => CreateLookupKey(twe), twe => twe); List <MediaItem> localUnWatchedEpisodes = localEpisodes.Except(localWatchedEpisodes).ToList(); foreach (var episode in localUnWatchedEpisodes) { string tvdbKey = CreateLookupKey(episode); var traktEpisode = onlineEpisodes[tvdbKey].FirstOrDefault(); if (traktEpisode != null) { _mediaPortalServices.GetLogger().Info( "Marking episode as watched in library, episode is watched on trakt. Plays = '{0}', Title = '{1}', Year = '{2}', Season = '{3}', Episode = '{4}', Show TVDb ID = '{5}', Show IMDb ID = '{6}', Last Watched = '{7}'", traktEpisode.Plays, traktEpisode.ShowTitle, traktEpisode.ShowYear.HasValue ? traktEpisode.ShowYear.ToString() : "<empty>", traktEpisode.Season, traktEpisode.Number, traktEpisode.ShowTvdbId.HasValue ? traktEpisode.ShowTvdbId.ToString() : "<empty>", traktEpisode.ShowImdbId ?? "<empty>", traktEpisode.WatchedAt); if (_mediaPortalServices.MarkAsWatched(episode).Result) { syncEpisodesResult.MarkedAsWatchedInLibrary++; } } } } #endregion #region Add episodes to watched history at trakt.tv ITraktSyncHistoryPost syncHistoryPost = GetWatchedShowsForSync(localWatchedEpisodes, traktWatchedEpisodes); if (syncHistoryPost.Shows != null && syncHistoryPost.Shows.Any()) { _mediaPortalServices.GetLogger().Info("Trakt: trying to add {0} watched episodes to trakt watched history", syncHistoryPost.Shows.Count()); ITraktSyncHistoryPostResponse response = _traktClient.AddWatchedHistoryItems(syncHistoryPost); syncEpisodesResult.AddedToTraktWatchedHistory = response.Added?.Episodes; _traktCache.ClearLastActivity(FileName.WatchedEpisodes.Value); if (response.Added?.Episodes != null) { _mediaPortalServices.GetLogger().Info("Trakt: successfully added {0} watched episodes to trakt watched history", response.Added.Episodes.Value); } } #endregion #region Add episodes to collection at trakt.tv ITraktSyncCollectionPost syncCollectionPost = GetCollectedShowsForSync(localEpisodes, traktCollectedEpisodes); if (syncCollectionPost.Shows != null && syncCollectionPost.Shows.Any()) { _mediaPortalServices.GetLogger().Info("Trakt: trying to add {0} collected episodes to trakt collection", syncCollectionPost.Shows.Count()); ITraktSyncCollectionPostResponse response = _traktClient.AddCollectionItems(syncCollectionPost); syncEpisodesResult.AddedToTraktCollection = response.Added?.Episodes; _traktCache.ClearLastActivity(FileName.CollectedEpisodes.Value); if (response.Added?.Episodes != null) { _mediaPortalServices.GetLogger().Info("Trakt: successfully added {0} collected episodes to trakt collection", response.Added.Episodes.Value); } } #endregion return(syncEpisodesResult); }
public void ReplaceIndexersCalls(MethodDefinition method, IList <SliceParameters> slices) { var processor = method.Body.GetILProcessor(); var instructions = processor.Body.Instructions; var slicesLookup = slices.ToLookup(x => x.Definition); for (int offset = 0; offset < instructions.Count; offset++) { var instruction = instructions[offset]; if (!instruction.OpCode.IsCall()) { continue; } var methodReference = instruction.Operand as MethodReference; if (methodReference == null) { continue; } if (methodReference.Name != "get_Item" && methodReference.Name != "set_Item") { continue; } var objectToCall = instruction.TraceBack(methodReference, 0); var parameter = instruction.TraceBack(methodReference, -1); var slice = slicesLookup[objectToCall.Operand].FirstOrDefault(); if (slice == null) { continue; } var arraySliceType = ModuleDefinition.Import(typeof(ArraySlice <>)).MakeGenericInstanceType(slice.GenericArgument); var methodDefinition = methodReference.Resolve(); // FIXME: We know we cannot process if anything happens between the push of the array slice and the final operation. if (methodDefinition.IsGetter) { // Original GET: // 1 ldarg.s segment $ Push the object to call // = ldloc.1 $ Push the parameter // 2 callvirt instance !0 class ArraySegment.ArraySlice`1<float32>::get_Item(int32) // = stloc.s t $ Do whatever with the result of the GET call // Target GET: // 1 ldloc.s data $ Push the object to call // = ldloc.1 $ Push the parameter // 2 ldloc.s offset // 2 add $ Add the parameter (i) and the offset. // 2 ldelem.r4 $ Use standard ldelem with type to get the value from the array. // = stloc.s t $ Do whatever with the result of the GET call //HACK: We rewrite it to avoid killing the loop. objectToCall.OpCode = OpCodes.Ldloc; objectToCall.Operand = slice.ArrayVariable; processor.Replace(instruction, Instruction.Create(OpCodes.Ldelem_Any, slice.GenericArgument)); processor.InsertAfter(parameter, new[] { Instruction.Create(OpCodes.Ldloc, slice.OffsetVariable), Instruction.Create(OpCodes.Add) }); } else if (methodDefinition.IsSetter) { // Original SET: // 1 ldarg segment $ Push the object to call // = ldloc.0 $ Push the parameter // = ldc.r4 2 $ Push the value to set // 2 callvirt instance void class ArraySegment.ArraySlice`1<float32>::set_Item(int32, !0) // - nop $ Check if it even exists after SimplifyMacros in the collection. // Target SET // 1 ldloc data $ Push the array // = ldloc.0 $ Push the parameter // 2 ldloc offset // 2 add $ Add the parameter (i) and the offset. // = ldc.r4 2 $ Push the value to set. Use standard ldc with type and check if it is optimized afterwards. // 2 stelem $ Use standard stelem with type and check if it is optimized afterwards. //HACK: We rewrite it to avoid killing the loop. objectToCall.OpCode = OpCodes.Ldloc; objectToCall.Operand = slice.ArrayVariable; processor.Replace(instruction, Instruction.Create(OpCodes.Stelem_Any, slice.GenericArgument)); processor.InsertAfter(parameter, new[] { Instruction.Create(OpCodes.Ldloc, slice.OffsetVariable), Instruction.Create(OpCodes.Add) }); } else { continue; } } }
public override void OnExtractionSuccess(string filePath, IList <Directory> directories, string relativePath, TextWriter log, long streamPosition) { base.OnExtractionSuccess(filePath, directories, relativePath, log, streamPosition); try { using (var writer = OpenWriter(filePath)) { try { // Write any errors if (directories.Any(d => d.HasError)) { foreach (var directory in directories) { if (!directory.HasError) { continue; } foreach (var error in directory.Errors) { writer.Write("[ERROR: {0}] {1}\n", directory.Name, error); } } writer.Write('\n'); } // Write tag values for each directory foreach (var directory in directories) { var directoryName = directory.Name; foreach (var tag in directory.Tags) { var tagName = tag.Name; var description = tag.Description; if (directory is FileMetadataDirectory && tag.Type == FileMetadataDirectory.TagFileModifiedDate) { description = "<omitted for regression testing as checkout dependent>"; } writer.Write("[{0} - 0x{1:x4}] {2} = {3}\n", directoryName, tag.Type, tagName, description); } if (directory.TagCount != 0) { writer.Write('\n'); } var xmpDirectory = directory as XmpDirectory; if (xmpDirectory?.XmpMeta != null) { var wrote = false; foreach (var prop in xmpDirectory.XmpMeta.Properties) { var value = prop.Value; if (value?.Length > 512) { value = value.Substring(0, 512) + $" <truncated from {value.Length} characters>"; } writer.WriteLine($"[XMPMeta - {prop.Namespace}] {prop.Path} = {value}"); wrote = true; } if (wrote) { writer.Write('\n'); } } } // Write file structure var tree = directories.ToLookup(d => d.Parent); void WriteLevel(Directory parent, int level) { const int indent = 4; foreach (var child in tree[parent]) { writer.Write(new string(' ', level * indent)); writer.Write($"- {child.Name}\n"); WriteLevel(child, level + 1); } } WriteLevel(null, 0); writer.Write('\n'); } finally { writer.Write("Generated using metadata-extractor\n"); writer.Write("https://drewnoakes.com/code/exif/\n"); } } } catch (Exception e) { log.Write("Exception after extraction: {0}\n", e.Message); } }
public bool WordBreak2(string s, IList <string> wordDict) { /* * 将一长串字符,拆分成已知的多个单词,是否可行 * 思路: * 1.依据已知的单词,将串从头开始拆分,拆分成:已知的串+待拆分的串;-->大问题可以拆分成同类的小问题,可以考虑使用递归 * 2.不同的拆分方法,最后可能面临相同的待拆分串; -->面临重复的子问题 * 3.可以考虑使用备忘录的方式,将待拆分串与拆分结果关联起来; -->做合理的剪枝,让回溯也能接近动态规划的效率 * * 时间复杂度:O(n*m) * 空间复杂度:O(n*m) * * 考察点: * 1.回溯法 + 备忘录 */ //单词分组 if (!charDic.Any()) { charDic = wordDict.ToLookup(i => i[0], j => j).ToDictionary(i => i.Key, j => j.ToList()); } //备忘录读取 if (memoDic.ContainsKey(s)) { return(memoDic[s]); } //特殊情况处理 if (string.IsNullOrWhiteSpace(s)) { return(true); } //正常的业务比较 var firstChar = s[0]; var words = charDic.ContainsKey(firstChar) ? charDic[firstChar] : new List <string>(); foreach (var wordItem in words) { if (s.Length < wordItem.Length) { continue; } if (s.Substring(0, wordItem.Length) != wordItem) { continue; } var newStr = new string(s.Skip(wordItem.Length).Take(s.Length - wordItem.Length).ToArray()); if (WordBreak(newStr, wordDict)) { memoDic[newStr] = true; return(true); } else { memoDic[newStr] = false; } } return(false); }