static void Main(string[] args) { /* The words of the dictionary this evil hangman example works with are supplied in the linear array below. * For a more sophisticated implementation loading from an external file is obviously possible, but the idea here * was to provide a simple solution to the problem, so beginner programmers could understand how they could solve * it themselves. */ string[] dict = {"bakalava", "balamata", "balerina", "balirina", "baniceta", "kalotina", "kolibata", "korubata"}; HashSet<string> words = new HashSet<string>(dict); char[] seq = {'l', 'r', 'i', 'o', 'e', 'n', 'm', 'k', 'v', 't', 'b', 'c', 'd', 'f', 'g', 'h', 'j', 'p', 'r', 's', 'u', 'w', 'x', 'y', 'z'}; HashSet<char> toGuess = new HashSet<char>(seq); Random rand = new Random(); Console.WriteLine("Pick a word: (1-" + words.Count + ")"); int ind = int.Parse(Console.ReadLine()); Console.WriteLine("The word you chose is " + answer + ". Let's see whether the computer can guess it..."); answer = dict[ind - 1]; guessed.Add(answer[0]); guessed.Add(answer[answer.Length - 1]); while (words.Count != 1) { words.RemoveWhere(Remover); PrintGuessed(guessed); Console.WriteLine(string.Join(", ", words)); guessed.Add(toGuess.First()); toGuess.Remove(toGuess.First()); } Console.WriteLine("The word is: " + words.First()); Console.ReadLine(); }
private static HashSet<Point> GetFreePointsInRange(Point pivotPoint) { // The 8 points below are the 8 possible moves of a horse if is not near the end of a board Point topRight = new Point(pivotPoint.Row + 2, pivotPoint.Col + 1); Point topLeft = new Point(pivotPoint.Row + 2, pivotPoint.Col - 1); Point rightUpper = new Point(pivotPoint.Row + 1, pivotPoint.Col + 2); Point rightLower = new Point(pivotPoint.Row - 1, pivotPoint.Col + 2); Point leftUpper = new Point(pivotPoint.Row + 1, pivotPoint.Col - 2); Point leftLower = new Point(pivotPoint.Row - 1, pivotPoint.Col - 2); Point bottomRight = new Point(pivotPoint.Row - 2, pivotPoint.Col + 1); Point bottomLeft = new Point(pivotPoint.Row - 2, pivotPoint.Col - 1); HashSet<Point> freePointsInRange = new HashSet<Point>() { topRight, topLeft, rightUpper, rightLower, leftUpper, leftLower, bottomRight, bottomLeft }; // Removes each point that is out of the board or that has been visited freePointsInRange.RemoveWhere(x => x.Col < 0 || x.Row < 0 || x.Row >= matrix.GetLength(0) || x.Col >= matrix.GetLength(1) || matrix[x.Row, x.Col] != 0); return freePointsInRange; }
public void FilterEntities(BattleEntity sourceEntity, HashSet<BattleEntity> entities) { switch(mTargetParam) { case AISkillRule.ConditionTarget.ENEMY: entities.RemoveWhere(FilterEnemy); break; case AISkillRule.ConditionTarget.PC: entities.RemoveWhere(FilterPC); break; case AISkillRule.ConditionTarget.SELF: entities.RemoveWhere(delegate(BattleEntity obj) { return sourceEntity != obj; }); break; } }
public int LadderLength(string start, string end, string[] dict) { HashSet<string> hset = new HashSet<string>(dict); HashSet<string> currentStarts = new HashSet<string>() { start }; int answer = 1; while (true) { hset.RemoveWhere(v => currentStarts.Contains(v)); HashSet<string> nextStarts = new HashSet<string>(); foreach (var starting in currentStarts) { if (starting == end) { return answer; } GetValidMoves(starting, hset).ToList().ForEach(n => nextStarts.Add(n)); } if (nextStarts.Count > 0) { answer++; currentStarts = nextStarts; } else { return 0; } } }
public static int Circulars(int range) { int count = 0; HashSet<int> primes = new HashSet<int>(); primes.UnionWith(Primes.primeRange(range)); HashSet<string> stringprimes = new HashSet<string>(); stringprimes.UnionWith(primes.Select<int, string>(x => x.ToString())); stringprimes.RemoveWhere(x => x.Contains('2') || x.Contains('4') || x.Contains('6') || x.Contains('8') || x.Contains('0')); foreach (string number in stringprimes) { string varnumber = number.Substring(0); bool allPrime = true; for (int i = 0; i < number.Length; i++) { char c = varnumber.First<char>(); varnumber += c; varnumber = varnumber.Remove(0, 1); if (!primes.Contains(int.Parse(varnumber))) { //Console.WriteLine(number); allPrime = false; break; } } if (allPrime == true) { count++; } allPrime = true; } return count + 1; }
public void Execute() { var mask = new NodeMask(); mask.Label = "Cycles"; mask.IsShowMask = true; try { if (!myPresentation.Graph.Nodes.Any()) { return; } var unvisited = new HashSet<Node>(myPresentation.Graph.Nodes); unvisited.RemoveWhere(n => n.In.Count == 0 || n.Out.Count == 0); while (unvisited.Count > 0) { var current = unvisited.First(); unvisited.Remove(current); foreach (var node in FindCycles(unvisited, current, new HashSet<Node> { current })) { mask.Set(node); } } } finally { var module = myPresentation.GetModule<INodeMaskModule>(); module.Push(mask); } }
public static HashSet<Triangle> Shrink(HashSet<Triangle> set) { HashSet<Triangle> Shrunk = new HashSet<Triangle>(set); Shrunk.RemoveWhere(t => t.Neighbors.Any(i => !set.Contains(i))); return Shrunk; }
public override string ToString() { if (OperationTypes == null || OperationTypes.Count == 0) return null; var uniqueTypes = new HashSet<Type>(); var uniqueTypeNames = new List<string>(); foreach (var type in OperationTypes) { foreach (var assemblyType in type.Assembly.GetTypes()) { if (assemblyType.GetCustomAttributes(typeof(DataContractAttribute), false).Length > 0) { var baseTypeWithSameName = XsdMetadata.GetBaseTypeWithTheSameName(assemblyType); if (uniqueTypeNames.Contains(baseTypeWithSameName.GetOperationName())) { log.WarnFormat("Skipping duplicate type with existing name '{0}'", baseTypeWithSameName.GetOperationName()); } uniqueTypes.Add(baseTypeWithSameName); } } } uniqueTypes.RemoveWhere(x => x.IsGenericTypeDefinition()); this.OperationTypes = uniqueTypes; var schemaSet = XsdUtils.GetXmlSchemaSet(OperationTypes); var xsd = XsdUtils.GetXsd(schemaSet); var filteredXsd = Filter(xsd); return filteredXsd; }
/// <summary> /// Removes all methods from the set that are not compatible to the signature of the <pramref name="signature" />. /// </summary> /// <param name="methods">The set of methods that should be filtered.</param> /// <param name="delegateType">The signature the methods must be compatible to.</param> public static void Filter(HashSet<IMethodSymbol> methods, INamedTypeSymbol delegateType) { Requires.NotNull(methods, nameof(methods)); Requires.NotNull(delegateType, nameof(delegateType)); Requires.That(delegateType.TypeKind == TypeKind.Delegate, "Expected a delegate type."); methods.RemoveWhere(port => !port.IsSignatureCompatibleTo(delegateType.DelegateInvokeMethod)); }
/// <inheritdoc /> public IEnumerable<TagHelperDescriptor> Resolve([NotNull] TagHelperDescriptorResolutionContext context) { var resolvedDescriptors = new HashSet<TagHelperDescriptor>(TagHelperDescriptorComparer.Default); // tagHelperPrefix directives do not affect which TagHelperDescriptors are added or removed from the final // list, need to remove them. var actionableDirectiveDescriptors = context.DirectiveDescriptors.Where( directive => directive.DirectiveType != TagHelperDirectiveType.TagHelperPrefix); foreach (var directiveDescriptor in actionableDirectiveDescriptors) { try { var lookupInfo = GetLookupInfo(directiveDescriptor, context.ErrorSink); // Could not resolve the lookup info. if (lookupInfo == null) { return Enumerable.Empty<TagHelperDescriptor>(); } if (directiveDescriptor.DirectiveType == TagHelperDirectiveType.RemoveTagHelper) { resolvedDescriptors.RemoveWhere(descriptor => MatchesLookupInfo(descriptor, lookupInfo)); } else if (directiveDescriptor.DirectiveType == TagHelperDirectiveType.AddTagHelper) { var descriptors = ResolveDescriptorsInAssembly( lookupInfo.AssemblyName, directiveDescriptor.Location, context.ErrorSink); // Only use descriptors that match our lookup info descriptors = descriptors.Where(descriptor => MatchesLookupInfo(descriptor, lookupInfo)); resolvedDescriptors.UnionWith(descriptors); } } catch (Exception ex) { string directiveName; _directiveNames.TryGetValue(directiveDescriptor.DirectiveType, out directiveName); Debug.Assert(!string.IsNullOrEmpty(directiveName)); context.ErrorSink.OnError( directiveDescriptor.Location, Resources.FormatTagHelperDescriptorResolver_EncounteredUnexpectedError( "@" + directiveName, directiveDescriptor.DirectiveText, ex.Message)); } } var prefixedDescriptors = PrefixDescriptors(context, resolvedDescriptors); return prefixedDescriptors; }
public override void Run(string[] args) { var filenames = string.Empty; var options = new OptionSet() { { "f=|files=", "Merges the specified split files.", f => filenames = f } }; options.Parse(args); if (string.IsNullOrWhiteSpace(filenames)) { throw new OptionSetException(options); } var splitFiles = new HashSet<string>(Directory.EnumerateFiles(@".\", filenames)); var workFiles = new List<string>(splitFiles.Take(splitFiles.Count - Take >= Take ? Take : splitFiles.Count)); splitFiles.RemoveWhere(s => workFiles.Contains(s)); int splitId = 0; bool firstRun = true; var createdFiles = new HashSet<string>(); while (workFiles.Count > 1 || firstRun) { int written = 0; var multiQueue = new MultiQueue(workFiles); using (var stream = Utils.FindFirstSplitFile("merge", ref splitId)) { createdFiles.Add(stream.Name); Console.WriteLine("Merging {0} into {1}", string.Join(",", from f in workFiles select Path.GetFileName(f)), Path.GetFileName(stream.Name)); foreach (var item in multiQueue.Merge()) { stream.Write(item.ToGuid().ToByteArray(), 0, 16); if (++written % 1000000 == 0) { Console.WriteLine("Written {0} lines", written); } } } Console.WriteLine("Written {0} lines", written); Console.WriteLine("Excluded {0} duplicates.", multiQueue.Duplicates); if (!firstRun) { workFiles.ForEach(f => File.Delete(f)); } workFiles = new List<string>(splitFiles.Take(splitFiles.Count - Take >= Take ? Take : splitFiles.Count)); splitFiles.RemoveWhere(s => workFiles.Contains(s)); if (workFiles.Count < Take) { splitFiles = createdFiles; createdFiles = new HashSet<string>(); workFiles = new List<string>(splitFiles.Take(Take)); splitFiles.RemoveWhere(s => workFiles.Contains(s)); firstRun = false; } } }
HashSet<int> GenerateFourDigitTriangleNumbers() { var triangleNumbers = new HashSet<int>(); for (int i = 1; i < 1000; i++) { triangleNumbers.Add(i * (i + 1) / 2); } triangleNumbers.RemoveWhere(tn => tn / 1000 >= 1 && tn / 1000 < 10); return triangleNumbers; }
HashSet<int> GenerateFourDigitSquareNumbers() { var squareNumbers = new HashSet<int>(); for (int i = 1; i < 100; i++) { squareNumbers.Add(i * i); } squareNumbers.RemoveWhere(sn => sn / 1000 >= 1 && sn / 1000 < 10); return squareNumbers; }
public void FilterEntities(BattleEntity sourceEntity, HashSet<BattleEntity> entities) { switch(mHpCondition) { case AISkillRule.HitPointCondition.HP_DEAD: entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curHP > 0; }); break; case AISkillRule.HitPointCondition.HP_GT: entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curHP / obj.character.maxHP <= mHpPercValue; }); break; case AISkillRule.HitPointCondition.HP_LT: entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curHP / obj.character.maxHP >= mHpPercValue; }); break; // highest, just find the max case AISkillRule.HitPointCondition.HP_HIGHEST: float maxHP = -1; foreach(BattleEntity entity in entities) { maxHP = Mathf.Max(maxHP, entity.character.curHP); } entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curHP != maxHP; }); break; case AISkillRule.HitPointCondition.HP_LOWEST: float minHP = 9999999; foreach(BattleEntity entity in entities) { // we want to make sure we dont count dead people minHP = Mathf.Max(1, Mathf.Min(minHP, entity.character.curHP)); } entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curHP != minHP; }); break; } }
public void FilterEntities(BattleEntity sourceEntity, HashSet<BattleEntity> entities) { switch(mHpCondition) { case AISkillRule.ResourceCondition.RES_EMPTY: entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curResource > 0; }); break; case AISkillRule.ResourceCondition.RES_GT: entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curResource / obj.character.maxResource <= mHpPercValue; }); break; case AISkillRule.ResourceCondition.RES_LT: entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curResource / obj.character.maxResource >= mHpPercValue; }); break; // highest, just find the max case AISkillRule.ResourceCondition.RES_HIGHEST: float maxResource = -1; foreach(BattleEntity entity in entities) { maxResource = Mathf.Max(maxResource, entity.character.curResource); } entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curResource != maxResource; }); break; case AISkillRule.ResourceCondition.RES_LOWEST: float minResource = 9999999; foreach(BattleEntity entity in entities) { // we want to make sure we dont count dead people minResource = Mathf.Min(minResource, entity.character.curResource); } entities.RemoveWhere(delegate(BattleEntity obj) { return obj.character.curResource != minResource; }); break; } }
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder) { Check.NotNull(modelBuilder, nameof(modelBuilder)); foreach (var entityType in modelBuilder.Metadata.GetEntityTypes()) { var unmappedProperty = entityType.GetProperties().FirstOrDefault(p => !IsMappedPrimitiveProperty(((IProperty)p).ClrType)); if (unmappedProperty != null) { throw new InvalidOperationException(CoreStrings.PropertyNotMapped(unmappedProperty.Name, entityType.Name)); } if (entityType.HasClrType()) { var clrProperties = new HashSet<string>(); clrProperties.UnionWith(entityType.ClrType.GetRuntimeProperties() .Where(pi => pi.IsCandidateProperty()) .Select(pi => pi.Name)); clrProperties.ExceptWith(entityType.GetProperties().Select(p => p.Name)); clrProperties.ExceptWith(entityType.GetNavigations().Select(p => p.Name)); var entityTypeBuilder = modelBuilder.Entity(entityType.ClrType, ConfigurationSource.Convention); clrProperties.RemoveWhere(p => entityTypeBuilder.IsIgnored(p, ConfigurationSource.Convention)); if (clrProperties.Count > 0) { foreach (var clrProperty in clrProperties) { var actualProperty = entityType.ClrType.GetRuntimeProperty(clrProperty); var targetType = FindCandidateNavigationPropertyType(actualProperty); if (targetType != null) { if (!modelBuilder.IsIgnored(targetType.DisplayName(), ConfigurationSource.Convention)) { throw new InvalidOperationException(CoreStrings.NavigationNotAdded(actualProperty.Name, entityType.Name)); } } else { throw new InvalidOperationException(CoreStrings.PropertyNotAdded(actualProperty.Name, entityType.Name)); } } } } } return modelBuilder; }
// filter out by if targets are within range public void FilterEntities(BattleEntity sourceEntity, HashSet<BattleEntity> entities) { // first row filter PCCharacter.RowPosition rowPosition = PCCharacter.RowPosition.FRONT; switch(mRowCondition) { case AISkillRule.RowCondition.BACK_COUNT_GT: case AISkillRule.RowCondition.BACK_COUNT_LT: rowPosition = PCCharacter.RowPosition.BACK; break; case AISkillRule.RowCondition.FRONT_COUNT_GT: case AISkillRule.RowCondition.FRONT_COUNT_LT: rowPosition = PCCharacter.RowPosition.FRONT; break; case AISkillRule.RowCondition.MIDDLE_COUNT_GT: case AISkillRule.RowCondition.MIDDLE_COUNT_LT: rowPosition = PCCharacter.RowPosition.MIDDLE; break; } // then remove all entries are not that row entities.RemoveWhere(delegate(BattleEntity obj) { if(obj is PCBattleEntity && ((PCBattleEntity)obj).pcCharacter.rowPosition == rowPosition) { return false; } return true; }); // finally see if it meets the condition, if it does, leave them, if it doesnt, remove all switch(mRowCondition) { case AISkillRule.RowCondition.BACK_COUNT_GT: case AISkillRule.RowCondition.FRONT_COUNT_GT: case AISkillRule.RowCondition.MIDDLE_COUNT_GT: if(entities.Count > mFilterCount) { // ok } else { entities.Clear(); } break; case AISkillRule.RowCondition.BACK_COUNT_LT: case AISkillRule.RowCondition.FRONT_COUNT_LT: case AISkillRule.RowCondition.MIDDLE_COUNT_LT: if(entities.Count < mFilterCount) { // ok } else { entities.Clear(); } break; } }
/// <summary> /// Creates all tags in supplied collection that don't already exist and returns the newly created tags. /// </summary> public static IEnumerable<Tag> CreateAllIfNotExists(this DbSet<Tag> source, IEnumerable<string> tags) { var tagSet = new HashSet<string>(tags); var existingTags = source .Where(t => tagSet.Contains(t.Name)) .Select(t => t.Name) .ToList(); // consume to get result out of DB tagSet.RemoveWhere(tag => existingTags.Contains(tag)); var newTags = tagSet.Select(t => new Tag { Name = t }); source.AddRange(newTags); return newTags; }
public Algoritmo( string path, string pred_obj) { predicados = new HashSet<Literal>(); dominio = new HashSet<string>(); baseConocimiento = new List<Literal>(); conocimientoPos = new List<Literal>(); conocimientoNeg = new List<Literal>(); objetivo = pred_obj; var file = (from lines in File.ReadAllLines(@path) let line = lines.Split(new[] { "(" }, StringSplitOptions.RemoveEmptyEntries) select new { predicado = line[0], atributos = line[1].Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries) } ); foreach (var lit in file) { int natt = lit.atributos.Count(); Literal nuevo = new Literal(lit.predicado, natt); predicados.Add(nuevo.Clone()); //para tener la cardinalidad tb string[] att = lit.atributos; att[natt - 1] = att[natt - 1].Remove(att[natt - 1].Count() - 1); nuevo.Atributos = att; dominio.UnionWith(att); if (lit.predicado == pred_obj) conocimientoPos.Add(nuevo); else { baseConocimiento.Add(nuevo); //predicados.Add(lit.predicado); //Para recursivo poner fuera del else } } predicados.RemoveWhere(T => T.Nombre == objetivo); int n_att = conocimientoPos[0].nAtt; foreach (var litNeg in dominio.Repetitions(n_att)) { Literal nuevo = new Literal(pred_obj, n_att); nuevo.Atributos = litNeg; conocimientoNeg.Add(nuevo); } conocimientoNeg.RemoveAll(T => conocimientoPos.Contains(T)); }
double IClassifier.Classify(string sample) { if (!isTrained) throw new NotTrainedException(); var tokens = new HashSet<string>(Utils.ExtractWords(sample)); tokens.RemoveWhere(e => this.stopWords.Contains(e)); double logProb1 = CalculateSampleLogProbability(tokens, this.logProbabilities1); double logProb2 = CalculateSampleLogProbability(tokens, this.logProbabilities2); // numerically safer calculation for (-1*p1 + 1*p2)/(p1 + p2) double logDiff = logProb1 - logProb2; double diff = Math.Exp(-Math.Abs(logDiff)); double result = -Math.Sign(logDiff) * (1 - diff) / (1 + diff); // Console.WriteLine("Actual result: " + result); return result; }
public IEnumerable<string> GetItems(string fullPath, ItemType itemType) { // REVIEW: We should pass the filter to this method so it happens on the server // REVIEW: Can we do some smart caching so we don't hit the server every time this is called? var itemSet = _workspace.VersionControlServer.GetItems(fullPath, TFS.VersionSpec.Latest, RecursionType.OneLevel, DeletedState.NonDeleted, itemType); // Get the local files for the server files var items = new HashSet<string>(from item in itemSet.Items select GetLocalItemForServerItem(item.ServerItem), StringComparer.OrdinalIgnoreCase); // Remove the path from the list if we're looking for folders if (itemType == ItemType.Folder) { items.Remove(fullPath); if (Directory.Exists(fullPath)) { // Files might have pending adds, but directories might not // (even though they get added as a result of checking in those files). foreach (var directory in Directory.EnumerateDirectories(fullPath)) { items.Add(directory); } } } // Remove pending deletes from the items collection foreach (var change in GetPendingChanges(fullPath, RecursionType.OneLevel)) { if (change.IsDelete) { // Remove all children of this path items.RemoveWhere(item => item.StartsWith(change.LocalItem, StringComparison.OrdinalIgnoreCase)); } else { items.Add(change.LocalItem); } } return items; }
static int Main(string[] args) { object obj = new object(); HashSet<object> hashset; Object[] oa = new Object[2]; hashset = new HashSet<object>(); hashset.Add(obj); hashset.Remove(obj); //Regression test: make sure these don't throw. foreach (object o in hashset) { } hashset.CopyTo(oa, 0, 2); hashset.RemoveWhere(MyPredicate); return 100; }
/// <summary> /// Finds the path using Iterative Deepening method /// </summary> public override void FindPath() { grid.ResetNodes(meshCopy); HashSet<Node> visitedHash = new HashSet<Node>(); Node startNode = grid.NodeFromWorldPoint(meshCopy, startPos); Node targetNode = grid.NodeFromWorldPoint(meshCopy, targetPos); visitedHash.Add(startNode); int depth = 0; path.pathSuccess = false; try { //Starts the stopwatch for timing the algorithm stopWatch = System.Diagnostics.Stopwatch.StartNew(); while(!path.pathSuccess && visitedHash.Count < grid.MaxSize) { path.pathSuccess = Deepening(startNode, depth, visitedHash, targetNode); visitedHash.RemoveWhere(n => n.parent != null && n != startNode); depth++; } if(path.pathSuccess) path.waypoints = RetracePath(startNode, targetNode); } catch(Exception ex) { Debug.Log("Error in find path method of IDeepening path"); path.pathSuccess = false; } stopWatch.Stop(); path.totalMs = totalMs + stopWatch.ElapsedMilliseconds; path.pathTime = stopWatch.ElapsedMilliseconds; path.totalNodes = visitedHash.Count; //This must be set to let the Pathfinding object know that thread has completed its job doneEvent.Set(); }
public static void Regression_Dev10_624201() { Predicate<object> predicate = (Object o) => { return false; }; object obj = new object(); HashSet<object> hashset; Object[] oa = new Object[2]; hashset = new HashSet<object>(); hashset.Add(obj); hashset.Remove(obj); //Regression test: make sure these don't throw. foreach (object o in hashset) { } hashset.CopyTo(oa, 0, 2); hashset.RemoveWhere(predicate); // we just want to make sure it doesn't throw. }
public static void Main() { var numbers = new HashSet<int>(); Console.WriteLine("Generating numbers..."); for (int i = 0; i < NumbersCount; i++) { numbers.Add(-i); } Console.WriteLine("Removing negative numbers..."); var sw = new Stopwatch(); sw.Start(); numbers.RemoveWhere(x => x < 0); sw.Stop(); Console.WriteLine($"Removal elapsed time: {(int)sw.Elapsed.TotalMilliseconds}ms"); Console.WriteLine(value: "Much faster than a list"); }
private void StartReaper() { Task.Factory.StartNew(async () => { await Task.Delay(1000).ConfigureAwait(false); Logger.Information("Reaper: started.."); var c = _consulPort > 0 ? new ConsulRestClient(_consulPort) : new ConsulRestClient(); var lookup = new HashSet<string>(); while (true) { try { var res = await c.GetCriticalServicesAsync().ConfigureAwait(false); foreach (var criticalServiceId in res) { if (lookup.Contains(criticalServiceId)) { await c.DeregisterServiceAsync(criticalServiceId).ConfigureAwait(false); Logger.Information("Reaper: Removing {ServiceId}", criticalServiceId); } else { lookup.Add(criticalServiceId); Logger.Information("Reaper: Marking {ServiceId}", criticalServiceId); } } //remove entries that are no longer critical lookup.RemoveWhere(i => !res.Contains(i)); } catch (Exception x) { Logger.Error(x, "Crashed"); } await Task.Delay(5000).ConfigureAwait(false); } }); }
public IList<AxisConstraint> GetAvailableSplits() { HashSet<AxisConstraint> availableSplits = new HashSet<AxisConstraint>(); AxisConstraint? minX = null, minY = null, minZ = null, maxX = null, maxY = null, maxZ = null; foreach(RotateableRegion region in _rotateableRegions) { IntBlockBounds rotatedBounds = region.RotatedBounds(); if (HasPivot(AxisConstraint.AxisType.X)) { availableSplits.Add(UpdateMinMax(ref minX, ref maxX, AxisConstraint.X(rotatedBounds.MinX))); availableSplits.Add(UpdateMinMax(ref minX, ref maxX, AxisConstraint.X(rotatedBounds.MaxX))); } if (HasPivot(AxisConstraint.AxisType.Y)) { availableSplits.Add(UpdateMinMax(ref minY, ref maxY, AxisConstraint.Y(rotatedBounds.MinY))); availableSplits.Add(UpdateMinMax(ref minY, ref maxY, AxisConstraint.Y(rotatedBounds.MaxY))); } if (HasPivot(AxisConstraint.AxisType.Z)) { availableSplits.Add(UpdateMinMax(ref minZ, ref maxZ, AxisConstraint.Z(rotatedBounds.MinZ))); availableSplits.Add(UpdateMinMax(ref minZ, ref maxZ, AxisConstraint.Z(rotatedBounds.MaxZ))); } } availableSplits.RemoveWhere(axisConstraint => axisConstraint.Equals(minX) || axisConstraint.Equals(maxX) || axisConstraint.Equals(minY) || axisConstraint.Equals(maxY) || axisConstraint.Equals(minZ) || axisConstraint.Equals(maxZ) || _rotateableRegions.Any(region => axisConstraint.IntersectedByBlockBounds(region.RotatedBounds())) ); return availableSplits.ToList(); }
public static HashSet<BuildingInfo> GetPillars(this NetInfo prefab) { HashSet<BuildingInfo> pillars = new HashSet<BuildingInfo>(); var roadAi = prefab.m_netAI as RoadBridgeAI; if (roadAi != null) { pillars.Add(roadAi.m_bridgePillarInfo); pillars.Add(roadAi.m_middlePillarInfo); } var trainTrackAi = prefab.m_netAI as TrainTrackBridgeAI; if (trainTrackAi != null) { pillars.Add(trainTrackAi.m_bridgePillarInfo); pillars.Add(trainTrackAi.m_middlePillarInfo); } var pedestrianPathAi = prefab.m_netAI as PedestrianBridgeAI; if (pedestrianPathAi != null) { pillars.Add(pedestrianPathAi.m_bridgePillarInfo); } pillars.RemoveWhere(bi => bi == null); return pillars; }
/// <summary> /// Generates a syntax tree for the provided assemblies. /// </summary> /// <param name="assemblies">The assemblies to generate code for.</param> /// <param name="runtime">Whether or not runtime code generation is being performed.</param> /// <returns>The generated syntax tree.</returns> private static GeneratedSyntax GenerateForAssemblies(List<Assembly> assemblies, bool runtime) { if (Logger.IsVerbose) { Logger.Verbose( "Generating code for assemblies: {0}", string.Join(", ", assemblies.Select(_ => _.FullName))); } Assembly targetAssembly; HashSet<Type> ignoredTypes; if (runtime) { // Ignore types which have already been accounted for. ignoredTypes = GetTypesWithGeneratedSupportClasses(); targetAssembly = null; } else { ignoredTypes = new HashSet<Type>(); targetAssembly = assemblies.FirstOrDefault(); } var members = new List<MemberDeclarationSyntax>(); // If any KnownAssemblies have been specified, include them during code generation. var knownAssemblies = assemblies.SelectMany(_ => _.GetCustomAttributes<KnownAssemblyAttribute>()) .Select(_ => _.Assembly) .Distinct() .ToSet(); if (knownAssemblies.Count > 0) { knownAssemblies.UnionWith(assemblies); assemblies = knownAssemblies.ToList(); } // Get types from assemblies which reference Orleans and are not generated assemblies. var includedTypes = new HashSet<Type>(); for (var i = 0; i < assemblies.Count; i++) { var assembly = assemblies[i]; foreach (var attribute in assembly.GetCustomAttributes<KnownTypeAttribute>()) { ConsiderType(attribute.Type, runtime, targetAssembly, includedTypes); } foreach (var type in assembly.DefinedTypes) { ConsiderType(type, runtime, targetAssembly, includedTypes); } } includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_)); // Group the types by namespace and generate the required code in each namespace. foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_))) { var namespaceMembers = new List<MemberDeclarationSyntax>(); foreach (var type in group) { // The module containing the serializer. var module = runtime ? null : type.Module; // Every type which is encountered must be considered for serialization. Action<Type> onEncounteredType = encounteredType => { // If a type was encountered which can be accessed, process it for serialization. SerializerGenerationManager.RecordTypeToGenerate(encounteredType, module, targetAssembly); }; if (Logger.IsVerbose2) { Logger.Verbose2("Generating code for: {0}", type.GetParseableName()); } if (GrainInterfaceData.IsGrainInterface(type)) { if (Logger.IsVerbose2) { Logger.Verbose2( "Generating GrainReference and MethodInvoker for {0}", type.GetParseableName()); } GrainInterfaceData.ValidateInterfaceRules(type); namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType)); namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type)); } // Generate serializers. var first = true; Type toGen; while (SerializerGenerationManager.GetNextTypeToProcess(out toGen)) { if (!runtime) { if (first) { ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:"); first = false; } ConsoleText.WriteStatus( "\ttype " + toGen.FullName + " in namespace " + toGen.Namespace + " defined in Assembly " + toGen.Assembly.GetName()); } if (Logger.IsVerbose2) { Logger.Verbose2( "Generating & Registering Serializer for Type {0}", toGen.GetParseableName()); } namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType)); } } if (namespaceMembers.Count == 0) { if (Logger.IsVerbose) { Logger.Verbose2("Skipping namespace: {0}", group.Key); } continue; } members.Add( SF.NamespaceDeclaration(SF.ParseName(group.Key)) .AddUsings( TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions)) .Select(_ => SF.UsingDirective(SF.ParseName(_))) .ToArray()) .AddMembers(namespaceMembers.ToArray())); } return new GeneratedSyntax { SourceAssemblies = assemblies, Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null }; }
internal static void WriteProjectXml( XmlWriter writer, string projectPath, string sourcePath, string filters, string startupFile, bool excludeNodeModules, out Guid projectGuid ) { var projectHome = CommonUtils.GetRelativeDirectoryPath(Path.GetDirectoryName(projectPath), sourcePath); projectGuid = Guid.NewGuid(); writer.WriteStartDocument(); writer.WriteStartElement("Project", "http://schemas.microsoft.com/developer/msbuild/2003"); writer.WriteAttributeString("DefaultTargets", "Build"); writer.WriteStartElement("PropertyGroup"); writer.WriteStartElement("Configuration"); writer.WriteAttributeString("Condition", " '$(Configuration)' == '' "); writer.WriteString("Debug"); writer.WriteEndElement(); writer.WriteElementString("SchemaVersion", "2.0"); writer.WriteElementString("ProjectGuid", projectGuid.ToString("B")); writer.WriteElementString("ProjectHome", projectHome); writer.WriteElementString("ProjectView", "ShowAllFiles"); if (CommonUtils.IsValidPath(startupFile)) { writer.WriteElementString("StartupFile", Path.GetFileName(startupFile)); } else { writer.WriteElementString("StartupFile", String.Empty); } writer.WriteElementString("WorkingDirectory", "."); writer.WriteElementString("OutputPath", "."); writer.WriteElementString("ProjectTypeGuids", "{3AF33F2E-1136-4D97-BBB7-1795711AC8B8};{349c5851-65df-11da-9384-00065b846f21};{9092AA53-FB77-4645-B42D-1CCCA6BD08BD}"); bool typeScriptSupport = EnumerateAllFiles(sourcePath, filters, excludeNodeModules) .Any(filename => NodejsConstants.TypeScriptExtension.Equals(Path.GetExtension(filename), StringComparison.OrdinalIgnoreCase)); if (typeScriptSupport) { writer.WriteElementString("TypeScriptSourceMap", "true"); writer.WriteElementString("TypeScriptModuleKind", "CommonJS"); writer.WriteElementString("EnableTypeScript", "true"); } writer.WriteStartElement("VisualStudioVersion"); writer.WriteAttributeString("Condition", "'$(VisualStudioVersion)' == ''"); writer.WriteString("14.0"); writer.WriteEndElement(); writer.WriteStartElement("VSToolsPath"); writer.WriteAttributeString("Condition", "'$(VSToolsPath)' == ''"); writer.WriteString(@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)"); writer.WriteEndElement(); writer.WriteEndElement(); // </PropertyGroup> // VS requires property groups with conditions for Debug // and Release configurations or many COMExceptions are // thrown. writer.WriteStartElement("PropertyGroup"); writer.WriteAttributeString("Condition", "'$(Configuration)' == 'Debug'"); writer.WriteEndElement(); writer.WriteStartElement("PropertyGroup"); writer.WriteAttributeString("Condition", "'$(Configuration)' == 'Release'"); writer.WriteEndElement(); var folders = new HashSet<string>( Directory.EnumerateDirectories(sourcePath, "*", SearchOption.AllDirectories) .Select(dirName => CommonUtils.TrimEndSeparator( CommonUtils.GetRelativeDirectoryPath(sourcePath, dirName) ) ) .Where(ShouldIncludeDirectory) ); // Exclude node_modules and bower_components folders. if (excludeNodeModules) { folders.RemoveWhere(NodejsConstants.ContainsNodeModulesOrBowerComponentsFolder); } writer.WriteStartElement("ItemGroup"); foreach (var file in EnumerateAllFiles(sourcePath, filters, excludeNodeModules)) { var ext = Path.GetExtension(file); if (NodejsConstants.JavaScriptExtension.Equals(ext, StringComparison.OrdinalIgnoreCase)) { writer.WriteStartElement("Compile"); } else if (NodejsConstants.TypeScriptExtension.Equals(ext, StringComparison.OrdinalIgnoreCase)) { writer.WriteStartElement("TypeScriptCompile"); } else { writer.WriteStartElement("Content"); } writer.WriteAttributeString("Include", file); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteStartElement("ItemGroup"); foreach (var folder in folders.Where(s => !string.IsNullOrWhiteSpace(s)).OrderBy(s => s)) { writer.WriteStartElement("Folder"); writer.WriteAttributeString("Include", folder); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteStartElement("Import"); writer.WriteAttributeString("Project", @"$(MSBuildToolsPath)\Microsoft.Common.targets"); writer.WriteAttributeString("Condition", @"Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"); writer.WriteEndElement(); writer.WriteComment("Do not delete the following Import Project. While this appears to do nothing it is a marker for setting TypeScript properties before our import that depends on them."); writer.WriteStartElement("Import"); writer.WriteAttributeString("Project", @"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\TypeScript\Microsoft.TypeScript.targets"); writer.WriteAttributeString("Condition", @"False"); writer.WriteEndElement(); writer.WriteStartElement("Import"); writer.WriteAttributeString("Project", @"$(VSToolsPath)\Node.js Tools\Microsoft.NodejsTools.targets"); writer.WriteEndElement(); writer.WriteRaw(@" <ProjectExtensions> <VisualStudio> <FlavorProperties GUID=""{349c5851-65df-11da-9384-00065b846f21}""> <WebProjectProperties> <UseIIS>False</UseIIS> <AutoAssignPort>True</AutoAssignPort> <DevelopmentServerPort>0</DevelopmentServerPort> <DevelopmentServerVPath>/</DevelopmentServerVPath> <IISUrl>http://localhost:48022/</IISUrl> <NTLMAuthentication>False</NTLMAuthentication> <UseCustomServer>True</UseCustomServer> <CustomServerUrl>http://localhost:1337</CustomServerUrl> <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile> </WebProjectProperties> </FlavorProperties> <FlavorProperties GUID=""{349c5851-65df-11da-9384-00065b846f21}"" User=""""> <WebProjectProperties> <StartPageUrl> </StartPageUrl> <StartAction>CurrentPage</StartAction> <AspNetDebugging>True</AspNetDebugging> <SilverlightDebugging>False</SilverlightDebugging> <NativeDebugging>False</NativeDebugging> <SQLDebugging>False</SQLDebugging> <ExternalProgram> </ExternalProgram> <StartExternalURL> </StartExternalURL> <StartCmdLineArguments> </StartCmdLineArguments> <StartWorkingDirectory> </StartWorkingDirectory> <EnableENC>False</EnableENC> <AlwaysStartWebServerOnDebug>False</AlwaysStartWebServerOnDebug> </WebProjectProperties> </FlavorProperties> </VisualStudio> </ProjectExtensions> "); writer.WriteEndElement(); // </Project> writer.WriteEndDocument(); }