public static HashSet<String> GetReplaysInFolder(String folderPath, ReplayType type, bool recursive = true) { HashSet<String> replaysInFolder; if (type == ReplayType.Warcraft3) { //make a set of replays in the folder, and replays that exist replaysInFolder = new HashSet<String>(Directory.GetFiles(folderPath, "*.w3g")); if (recursive) { Queue<String> directories = new Queue<String>(Directory.GetDirectories(folderPath)); while (directories.Count > 0) { String dir = directories.Dequeue(); replaysInFolder = new HashSet<String>(replaysInFolder.Concat(Directory.GetFiles(dir, "*.w3g"))); directories = new Queue<String>(directories.Concat(Directory.GetDirectories(dir))); } HashSet<String> existingReplays = DatabaseHandler.GetWarcraft3ReplayPaths(); replaysInFolder.ExceptWith(existingReplays); } } //add new replay types here, otherwise an exception is thrown else { throw new ArgumentException(); } return replaysInFolder; }
/// <summary> /// Uses a djikstra-like algorithm to flood the graph from the start /// node until the target node is found. /// All visited nodes have their distance from the start node updated. /// </summary> /// <param name="start">The starting node.</param> /// <param name="target">The target node.</param> /// <param name="front">The last newly found nodes.</param> /// <param name="visited">The already visited nodes.</param> /// <param name="distFromStart">The traversed distance from the /// starting node in edges.</param> /// <returns>The distance from the start node to the target node.</returns> /// <remarks> - Currently the target node is never found if contained /// in front or visited. /// - If front = { start }, then distFromStart should be 0.</remarks> public int dijkstraStep(GraphNode start, GraphNode target, HashSet<GraphNode> front, HashSet<GraphNode> visited, int distFromStart) { HashSet<GraphNode> newFront = new HashSet<GraphNode>(); HashSet<GraphNode> newVisited = new HashSet<GraphNode>(visited); newVisited.Concat(front); foreach (GraphNode node in front) { newVisited.Add(node); foreach (GraphNode adjacentNode in node.Adjacent) { if (adjacentNode == target) return distFromStart + 1; // Could be combined in newVisited... if (visited.Contains(adjacentNode)) continue; if (front.Contains(adjacentNode)) continue; newFront.Add(adjacentNode); } } // This wouldn't need recursion, but it's more convenient this way. if (newFront.Count > 0) return dijkstraStep(start, target, newFront, newVisited, distFromStart + 1); throw new GraphNotConnectedException(); }
private static void ExcludeFiles(ICollection<IPackageFile> packageFiles) { // Always exclude the nuspec file // Review: This exclusion should be done by the package builder because it knows which file would collide with the auto-generated // manifest file. var excludes = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var wildCards = excludes.Concat(new[] {@"**\*" + Constants.ManifestExtension, @"**\*" + Constants.PackageExtension}); PathResolver.FilterPackageFiles(packageFiles, ResolvePath, wildCards); }
/// <summary> /// Combines and orders two parties by highest speed first. /// </summary> /// <param name="p1">Party 1</param> /// <param name="p2">Party 2</param> /// <returns>A HashSet of combined IEngageables from both parties sorted by descending speed.</returns> private static HashSet<IEngageable> arrangeAttackOrder(HashSet<IEngageable> p1, HashSet<IEngageable> p2) { HashSet<IEngageable> bothParties = new HashSet<IEngageable>(); IEnumerable<IEngageable> concat = p1.Concat(p2).OrderByDescending(member => member.getSpeed()); foreach (IEngageable member in concat) { bothParties.Add(member); } return bothParties; }
public Connection(IMessageBus messageBus, IJsonSerializer jsonSerializer, string baseSignal, string connectionId, IEnumerable<string> signals, IEnumerable<string> groups, ITraceManager traceManager) { _messageBus = messageBus; _serializer = jsonSerializer; _baseSignal = baseSignal; _connectionId = connectionId; _signals = new HashSet<string>(signals); _groups = new HashSet<string>(groups); _trace = traceManager; _signalsAndGroups = _signals.Concat(_groups); }
/* public static IAssemblySymbol[] GetReferencedAssemblies(IAssemblySymbol assembly) { var result = assembly.GetType().GetMethod("GetLinkedReferencedAssemblies", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(assembly, new object[0]); if (result == null) return new IAssemblySymbol[0]; return result.ToArray(); } */ public static IAssemblySymbol[] Sort(Tuple<IAssemblySymbol, IAssemblySymbol[]>[] assemblies) { var currentList = assemblies.ToList(); var prepend = new HashSet<Tuple<IAssemblySymbol, IAssemblySymbol[]>>(); do { prepend.Clear(); var indices = currentList.Select((x, i) => new { Item = x, Index = i }).ToDictionary(x => x.Item.Item1, x => x.Index); for (var i = 0; i < currentList.Count; i++) { var item = currentList[i]; foreach (var referencedAssembly in item.Item2) { int assemblyIndex; if (indices.TryGetValue(referencedAssembly, out assemblyIndex)) { if (assemblyIndex > i) { var referencedAssemblyItem = currentList[assemblyIndex]; prepend.Add(referencedAssemblyItem); } } } } if (prepend.Any()) { var newItems = prepend.Concat(currentList.Where(x => !prepend.Contains(x))).ToArray(); currentList.Clear(); currentList.AddRange(newItems); } } while (prepend.Any()); return currentList.Select(x => x.Item1).ToArray(); }
void solutionWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) { if (isCanceling || _stopReporting) { return; } progressBar.Value = e.ProgressPercentage; lblProgressText.Content = e.ProgressPercentage.ToString() + "/" + maxSteps; bestSoFar = (HashSet<ushort>)(e.UserState); lblBestResult.Content = string.Format(L10n.Plural("Best result so far: {0} additional point spent", "Best result so far: {0} additional points spent", (uint)bestSoFar.Count), bestSoFar.Count); tree.HighlightedNodes = new HashSet<ushort>(bestSoFar.Concat(tree.SkilledNodes)); tree.DrawNodeBaseSurroundHighlight(); }
public static HashSet<string> getDep(HashSet<string> dllSet, string fileName) { /* * Add Part where * !File.exists(fileName) download(); */ XmlTextReader reader = new XmlTextReader(fileName); HashSet<string> set_for_this_Dep = new HashSet<string>(); while (reader.Read()) { if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name == "Reference") { reader.Read(); string dllPath = reader.Value.Trim(); if (!dllSet.Contains(dllPath)) { dllSet.Add(dllPath); string depPath = dllPath.Substring(0, dllPath.Length-4) + ".dep"; set_for_this_Dep.Add(depPath); //dllSet.UnionWith(getDep(dllSet, depPath)); } } } foreach (string dll in set_for_this_Dep) { dllSet.Concat(getDep(new HashSet<string>(), dll)); } return dllSet; }
/// <summary> /// Gets all titles that are suitable for player. /// </summary> /// <param name="player">The player for title checks.</param> /// <returns>All title suitable for given player or an empty list if none.</returns> public static ICollection GetPlayerTitles(GamePlayer player) { var titles = new HashSet<IPlayerTitle>(); titles.Add(ClearTitle); return titles.Concat(m_titles.Where(t => t.IsSuitable(player))).ToArray(); }
public IndexDefinition CreateIndexDefinition() { var fromClauses = new HashSet<string>(); var realMappings = new HashSet<string>(); if (!string.IsNullOrEmpty(ForEntityName)) { fromClauses.Add("from doc in docs." + ForEntityName); } else { fromClauses.Add("from doc in docs"); } foreach (var map in Items) { var currentDoc = "doc"; var currentExpression = new StringBuilder(); int currentIndex = 0; while (currentIndex < map.From.Length) { char currentChar = map.From[currentIndex++]; switch (currentChar) { case ',': // doc.NewDoc.Items String newDocumentSource = string.Format("{0}.{1}", currentDoc, currentExpression); // docNewDocItemsItem String newDoc = string.Format("{0}Item", newDocumentSource.Replace(".", "")); // from docNewDocItemsItem in doc.NewDoc.Items String docInclude = string.Format("from {0} in ((IEnumerable<dynamic>){1}).DefaultIfEmpty()", newDoc, newDocumentSource); fromClauses.Add(docInclude); // Start building the property again currentExpression.Clear(); // And from this new doc currentDoc = newDoc; break; default: currentExpression.Append(currentChar); break; } } if (currentExpression.Length > 0 && currentExpression[0] != '[') { currentExpression.Insert(0, '.'); } // We get rid of any _Range(s) etc var indexedMember = currentExpression.ToString().Replace("_Range", ""); if (indexedMember.Length == 0) { realMappings.Add(string.Format("{0} = {1}", map.To.Replace("_Range", ""), currentDoc )); } else { realMappings.Add(string.Format("{0} = {1}{2}", map.To.Replace("_Range", ""), currentDoc, indexedMember )); } } var index = new IndexDefinition { Map = string.Format("{0}\r\nselect new {{ {1} }}", string.Join("\r\n", fromClauses.ToArray()), string.Join(", ", realMappings.Concat(new[] { AggregationMapPart() }).Where(x => x != null))), Reduce = DynamicAggregation ? null : AggregationReducePart(), TransformResults = DynamicAggregation ? AggregationReducePart() : null, }; if (DynamicAggregation) { foreach (var item in GroupByItems) { index.Stores[ToFieldName(item.To)] = FieldStorage.Yes; } } foreach (var descriptor in SortDescriptors) { index.SortOptions[ToFieldName(descriptor.Field)] = descriptor.FieldType; } foreach (var field in HighlightedFields.EmptyIfNull()) { index.Stores[field] = FieldStorage.Yes; index.Indexes[field] = FieldIndexing.Analyzed; } return index; }
public void ExecuteTheseHandlersFirst(params Type[] handlerTypes) { AssertInit(); var firstOrderedHandlers = new HashSet<Type>(); foreach (var handler in handlerTypes) { var firstOrderedHandler = orderedMessageHandlerList.FirstOrDefault(x => handler.IsAssignableFrom(x)); if (firstOrderedHandler != null && !firstOrderedHandlers.Contains(firstOrderedHandler)) { firstOrderedHandlers.Add(firstOrderedHandler); } } var allOtherHandlers = orderedMessageHandlerList.Except(firstOrderedHandlers).ToList(); orderedMessageHandlerList = firstOrderedHandlers.Concat(allOtherHandlers).ToList(); }
/// <summary> /// Converts an MST spanning a set of GraphNodes back into its equivalent /// as a HashSet of SkillNode IDs. /// </summary> /// <param name="mst">The spanned MinimalSpanningTree.</param> /// <param name="visualize">A debug parameter that highlights all used /// GraphNodes' SkillNode equivalents in the tree.</param> /// <returns>A HashSet containing the node IDs of all SkillNodes spanned /// by the MST.</returns> HashSet<ushort> SpannedMstToSkillnodes(MinimalSpanningTree mst, bool visualize) { if (!mst.IsSpanned) throw new Exception("The passed MST is not spanned!"); HashSet<ushort> newSkilledNodes = new HashSet<ushort>(); foreach (GraphEdge edge in mst.SpanningEdges) { ushort target = edge.outside.Id; HashSet<ushort> start; if (edge.inside is Supernode) start = tree.SkilledNodes; else start = new HashSet<ushort>() { edge.inside.Id }; var path = tree.GetShortestPathTo(target, start); newSkilledNodes = new HashSet<ushort>(newSkilledNodes.Concat(path)); } if (visualize) { tree._nodeHighlighter.UnhighlightAllNodes(NodeHighlighter.HighlightState.FromAttrib); foreach (GraphNode steinerNode in mst.mstNodes) tree._nodeHighlighter.HighlightNode(SkillTree.Skillnodes[steinerNode.Id], NodeHighlighter.HighlightState.FromAttrib); } //tree.DrawHighlights(tree._nodeHighlighter); return newSkilledNodes; }
private HashSet<FragmentQuery> GetUsedViewsAndRemoveTrueSurrogate(ref Tile<FragmentQuery> rewriting) { var usedViews = new HashSet<FragmentQuery>(rewriting.GetNamedQueries()); if (!usedViews.Contains(_trueViewSurrogate.Query)) { return usedViews; // no surrogate } // remove the surrogate usedViews.Remove(_trueViewSurrogate.Query); // first, try to union usedViews to see whether we can get True Tile<FragmentQuery> unionTile = null; var usedFollowedByUnusedViews = usedViews.Concat(_fragmentQueries); foreach (var view in usedFollowedByUnusedViews) { unionTile = (unionTile == null) ? CreateTile(view) : _qp.Union(unionTile, CreateTile(view)); usedViews.Add(view); if (IsTrue(unionTile.Query)) { // we found a true rewriting rewriting = rewriting.Replace(_trueViewSurrogate, unionTile); return usedViews; } } // now we either found the rewriting or we can just take all views because we are in relaxed mode for update views Debug.Fail("Shouldn't happen"); return usedViews; }
void solutionWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { if (isCanceling) { btnPopupPauseResume.IsEnabled = true; isCanceling = false; return; } lblProgressText.Content = L10n.Message("Finished!"); btnPopupCancelClose.Content = L10n.Message("Close"); btnPopupPauseResume.IsEnabled = false; bestSoFar = (HashSet<ushort>)e.Result; isPaused = true; // Draw the final solution in case not all ProgressChangeds get executed. progressBar.Value = maxSteps; lblBestResult.Content = string.Format(L10n.Plural("Best result so far: {0} additional point spent", "Best result so far: {0} additional points spent", (uint)bestSoFar.Count), bestSoFar.Count); tree.HighlightedNodes = new HashSet<ushort>(bestSoFar.Concat(tree.SkilledNodes)); tree.DrawNodeBaseSurroundHighlight(); }
static void Main(string[] args) { ConfigurationItemFactory.Default.Targets.RegisterDefinition("ServiceManager", typeof(ServiceManagerTarget)); string subdir = null, runDebugMethodOnExtension = null; var baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Extensions"); Environment.CurrentDirectory = ConfigurationManager.AppSettings["DataDirectory"] ?? AppDomain.CurrentDomain.BaseDirectory; var extensionIDs = new HashSet<string>(); Process process = null; Guid guid = Guid.Empty; Logger logger = null; var options = new OptionSet { { "guid=", "Specifies a GUID that the extension can use to identify itself to the parent process", v => { Guid id; if(!Guid.TryParse(v, out id)) throw new OptionException("The specified id was not a valid GUID", "guid"); guid = id; } }, { "basedir=", "Specifies the base plugins directory (can be relative or absolute)", v => baseDir = Path.IsPathRooted(v) ? v : Path.Combine(AppDomain.CurrentDomain.BaseDirectory, v) }, { "subdir=", "Specifies the extension subdirectory name", v => subdir = v }, { "debug=", "Specifies an extension ID to run the debug method on", v => runDebugMethodOnExtension = v }, { "pid=", "Parent process ID - if specified, this process will close when the parent process closes", v => { int pid; if(!int.TryParse(v, out pid)) throw new OptionException("The parent process ID must be a 32 bit integer", "pid"); try { process = Process.GetProcessById(pid); } catch(Exception ex) { throw new OptionException(ex.Message, "pid"); } if(process == null) throw new OptionException("There is no process with ID [" + pid + "]", "pid"); } }, { "<>", v => extensionIDs.Add(v) } }; CancellationTokenSource src = new CancellationTokenSource(); try { options.Parse(args); if(subdir == null) { Console.Write("Enter plugin directory name (not the full path): "); subdir = Console.ReadLine(); if(string.IsNullOrWhiteSpace(subdir)) { Console.WriteLine("No plugin directory specified."); Exit(null, src, ExtensionRunnerExitCode.InvalidArguments); } } GlobalDiagnosticsContext.Set("ExeBaseDir", new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName); GlobalDiagnosticsContext.Set("SubDirName", subdir); GlobalDiagnosticsContext.Set("ParentProcess", process == null ? "" : process.Id.ToString()); logger = LogManager.GetCurrentClassLogger(); logger.Info(new [] { "ExtensionRunner Started:", " => Command Line: " + Environment.CommandLine, " => Subdirectory: " + subdir, " => Base Directory: " + baseDir, " => Specified Extensions: " + extensionIDs.Concat(", "), " => GUID: " + guid, " => Parent Process ID: " + (process == null ? "(none)" : process.Id.ToString()) }.Concat(Environment.NewLine)); AppDomain.CurrentDomain.UnhandledException += (s,e) => logger.FatalException("UNTRAPPED SERVICE EXCEPTION", (Exception)e.ExceptionObject); TaskScheduler.UnobservedTaskException += (s,e) => logger.FatalException("UNTRAPPED TASK EXCEPTION:", e.Exception); if(process != null) { Task.Factory.StartNew(() => { while(!src.IsCancellationRequested) { process.Refresh(); if(process.HasExited) { logger.Warn("Detected parent process shutdown."); Exit(logger, src, ExtensionRunnerExitCode.ParentExited); return; } Thread.Sleep(250); } }); } // Read list of available extensions Dictionary<string, ExtensionInfo> extInfos; using(var loader = new SafeExtensionLoader(baseDir, subdir, process == null ? "" : process.Id.ToString(), src)) extInfos = loader.AvailableExtensions.ToDictionary(x => x.ExtensionID, x => x.Clone()); if(extensionIDs.Count == 0) extensionIDs = new HashSet<string>(extInfos.Select(x => x.Key)); // use all available extensions else extensionIDs = new HashSet<string>(extensionIDs.Where(x => extInfos.ContainsKey(x))); // eliminate invalid any extension IDs logger.Info("Active extensions: " + (extensionIDs.Any() ? extensionIDs.Concat(", ") : "(none)")); logger.Info("Inactive extensions: " + (!extensionIDs.Any() ? extInfos.Where(x => !extensionIDs.Contains(x.Key)).Concat(", ") : "(none)")); var extLoaders = new List<SafeExtensionLoader>(); var extTasks = new List<Task>(); try { foreach(var id in extensionIDs) { logger.Debug("Starting appdomain for extension: {0}", id); var loader = new SafeExtensionLoader(baseDir, subdir, process == null ? "" : process.Id.ToString(), src); var extID = id; extTasks.Add(Task.Factory.StartNew(() => loader.RunExtension(guid, runDebugMethodOnExtension == extID, extID))); } Task.WaitAll(extTasks.ToArray(), src.Token); } finally { foreach(var extLoader in extLoaders) extLoader.Dispose(); } //using(var loader = new SafeExtensionLoader(baseDir, subdir, process == null ? "" : process.Id.ToString(), src)) //{ // var runExtsTask = Task.Factory.StartNew(() => // { // // Verify that all extensions are available and if so, run them // var sb = new StringBuilder(); // sb.AppendLine("[list of all plugins]"); // foreach(var extInfo in loader.AllExtensions) // sb.AppendLine("\t" + extInfo.ExtensionID + ": " + extInfo.Name + " [" + (extensionIDs.Count == 0 || extensionIDs.Contains(extInfo.ExtensionID) ? "ACTIVE" : "INACTIVE") + "]"); // logger.Info(sb.ToString()); // loader.RunExtensions(guid, runDebugMethodOnExtension, extensionIDs.ToArray()); // }, src.Token); // loader.RunMainAppThread(); // Task.WaitAll(new[] { runExtsTask }, src.Token); //} } catch(OptionException ex) { if(logger != null) logger.Error("Invalid command options: " + ex.Message, options.WriteOptionDescriptions()); Exit(logger, src, ExtensionRunnerExitCode.Exception); } catch(Exception ex) { if(logger != null) logger.FatalException("An exception was thrown", ex); Exit(logger, src, ExtensionRunnerExitCode.Exception); } finally { Exit(logger, src, ExtensionRunnerExitCode.Success); } }
private void ProcessPublicBags(Random rand, Tuple<Player, int>[] dat) { var lootCount = PublicBag.BaseLootCount + PublicBag.PersonMultiplier*dat.Length; if (lootCount < PublicBag.MinLootCount) lootCount = PublicBag.MinLootCount; if (lootCount > PublicBag.MaxLootCount) lootCount = PublicBag.MaxLootCount; var loots = new HashSet<Item>(); var pots = new List<Item>(); for (var i = 0; i < lootCount || (loots.Count < PublicBag.MinLootCount && pots.Count < PublicBag.MinLootCount); i++) { var loot = PublicBag.GetRandomLoot(rand); if (loot != null) { if (loot.Potion) pots.Add(loot); else loots.Add(loot); } } ShowBags(rand, loots.Concat(pots), null); }
protected override void ProcessAssembly(AssemblyDefinition assemblyDef) { if (_frameworkProfile == null) { _frameworkProfile = assemblyDef.GuessAssemblyProfile(); } if (_frameworkProfile != null) { foreach (var moduleDef in assemblyDef.Modules) { var resolver = moduleDef.AssemblyResolver as DefaultAssemblyResolver; if (resolver != null) { resolver.AddSearchDirectory(_frameworkProfile.ReferencesDirectory); } } } _usedTypeReferences = new HashSet<TypeReference>(CecilEqualityComparer.Default); base.ProcessAssembly(assemblyDef); var unprocessedTypes = new Queue<TypeReference>(_usedTypeReferences); _usedTypeReferences = null; var processedTypes = new HashSet<TypeDefinition>(CecilEqualityComparer.Default); var unresolvedTypes = new HashSet<TypeReference>(CecilEqualityComparer.Default); while (unprocessedTypes.Any()) { var typeRef = unprocessedTypes.Dequeue(); if (typeRef == null) { continue; } if (typeRef.IsGenericParameter) { continue; } var typeSpec = typeRef as TypeSpecification; if (typeSpec != null) { var elementType = typeSpec.ElementType; Debug.Assert(elementType != null); unprocessedTypes.Enqueue(elementType); var genericInstanceTypeRef = typeRef as GenericInstanceType; if (genericInstanceTypeRef != null) { foreach (var genericArgument in genericInstanceTypeRef.GenericArguments) { unprocessedTypes.Enqueue(genericArgument); } } var requiredModifierTypeRef = typeRef as RequiredModifierType; if (requiredModifierTypeRef != null) { unprocessedTypes.Enqueue(requiredModifierTypeRef.ModifierType); } var optionalModifierTypeRef = typeRef as OptionalModifierType; if (optionalModifierTypeRef != null) { unprocessedTypes.Enqueue(optionalModifierTypeRef.ModifierType); } var functionPointerTypeRef = typeRef as FunctionPointerType; if (functionPointerTypeRef != null) { unprocessedTypes.Enqueue(functionPointerTypeRef.ReturnType); foreach (var parameter in functionPointerTypeRef.Parameters) { unprocessedTypes.Equals(parameter.ParameterType); foreach (var customAttr in parameter.CustomAttributes) { unprocessedTypes.Enqueue(customAttr.AttributeType); } } foreach (var customAttr in functionPointerTypeRef.MethodReturnType.CustomAttributes) { unprocessedTypes.Enqueue(customAttr.AttributeType); } } continue; } var typeDef = typeRef as TypeDefinition; if (typeDef == null) { typeDef = typeRef.TryResolve(); if (typeDef != null) { unprocessedTypes.Enqueue(typeDef); } else { unresolvedTypes.Add(typeRef); Debug.WriteLine(string.Format("Cannot resolve type {0}", typeRef.FullName)); } continue; } processedTypes.Add(typeDef); } _resolvedTypes = processedTypes; _unresolvedTypes = unresolvedTypes; _allTypes = new HashSet<TypeReference>(_unresolvedTypes.Concat(_resolvedTypes), CecilEqualityComparer.Default); }