public void FilterData(ZusaarJson zusaarResult, ObservableCollection<AllEventsInfo> allEventsInfo, HashSet<string> ngWordsList, HashSet<string> cities) { if (zusaarResult != null) { var zusaaarInfo = from evnt in zusaarResult._event where evnt.started_at <= DateTime.Now.AddMonths(5) where evnt.started_at > DateTime.Now join city in cities on SpecifyCity.GetCity(evnt.address) equals city where ngWordsList.All(word => !evnt.title.Contains(word)) select new AllEventsInfo { Site = "site_zusaar.png", Title = evnt.title, Event_uri = evnt.event_url, Start_at = evnt.started_at, End_at = evnt.ended_at, Description = evnt.description, Overview = HtmlToString.GetString(evnt.description, 50), Address = evnt.address, City = SpecifyCity.GetCity(evnt.address), Accepted = evnt.accepted, Limit = evnt.limit, Organizer = evnt.owner_nickname, }; foreach (var item in zusaaarInfo) { allEventsInfo.Add(item); } } }
//Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) //{ // throw new NotImplementedException(); //} private static string ImportsFor(HashSet<string> namespaces) { StringBuilder builder = new StringBuilder(); namespaces.All(s => { builder.AppendFormat("using {0};{1}", s, Environment.NewLine); return true; }); return builder.ToString(); }
public void FilterData(List<DoorkeeperJson> doorkeeperResult, ObservableCollection<AllEventsInfo> allEventsInfo, HashSet<string> ngWordsList, HashSet<string> cities) { if (doorkeeperResult != null) { var doorkeeperInfo = from evnt in doorkeeperResult join city in cities on SpecifyCity.GetCity(evnt._event.address) equals city where evnt._event.starts_at <= DateTime.Now.AddMonths(5) where evnt._event.starts_at > DateTime.Now where ngWordsList.All(word => !evnt._event.title.Contains(word)) select new AllEventsInfo { Site = "site_doorkeeper.png", Title = evnt._event.title, Event_uri = evnt._event.public_url, Start_at = evnt._event.starts_at, End_at = evnt._event.ends_at, Description = evnt._event.description, Overview = HtmlToString.GetString(evnt._event.description, 50), Address = evnt._event.address, City = SpecifyCity.GetCity(evnt._event.address), Accepted = evnt._event.participants, Limit = evnt._event.ticket_limit, Organizer = [email protected], }; foreach (var item in doorkeeperInfo) { allEventsInfo.Add(item); } } }
public void HashSetExtensions_All_ReturnsTrueIfHashSetIsEmpty() { var set = new HashSet<Int32>(); var result = set.All(x => x % 2 == 0); TheResultingValue(result).ShouldBe(true); }
public void HashSetExtensions_All_ReturnsTrueIfAllItemsMatchPredicate() { var set = new HashSet<Int32>() { 2, 4, 6 }; var result = set.All(x => x % 2 == 0); TheResultingValue(result).ShouldBe(true); }
public void HashSetExtensions_All_ReturnsFalseIfOneItemDoesNotMatchPredicate() { var set = new HashSet<Int32>() { 1, 2, 4, 6 }; var result = set.All(x => x % 2 == 0); TheResultingValue(result).ShouldBe(false); }
public bool IsInGeneratedCodeDocument([NotNull] ISymbol symbol, CancellationToken cancellationToken) { Guard.NotNull(symbol, nameof(symbol)); // Return false when not all locations have generated comment; for example, partial classes. IEnumerable<Location> locations = symbol.Locations.Where(location => location.IsInSource); var trees = new HashSet<SyntaxTree>(locations.Select(location => location.SourceTree)); return trees.Any() && trees.All(tree => IsGeneratedCodeDocument(tree, cancellationToken)); }
public void TrimExcess() { var set = new HashSet<int>(); foreach (int item in Enumerable.Range(100, 1000)) set.Add(item); Assert.AreEqual(1000, set.Count); set.TrimExcess(); Assert.AreEqual(1000, set.Count); foreach (int item in Enumerable.Range(100, 1000)) Assert.IsTrue(set.Contains(item)); foreach (int item in Enumerable.Range(100, 1000).Where(i => i % 2 == 0)) set.Remove(item); set.TrimExcess(); Assert.AreEqual(500, set.Count); Assert.IsTrue(set.All(i => i % 2 == 1)); }
public void RemoteRouter_must_deploy_remote_routers_based_on_explicit_deployment() { var probe = CreateTestProbe(masterActorSystem); var router = masterActorSystem.ActorOf(new RoundRobinPool(2).Props(Props.Create<Echo>()) .WithDeploy( new Deploy(new RemoteScope(intendedRemoteAddress))), "remote-blub2"); router.Path.Address.ShouldBe(intendedRemoteAddress); var replies = new HashSet<ActorPath>(); for (var i = 0; i < 5; i++) { router.Tell("", probe.Ref); var expected = probe.ExpectMsg<IActorRef>(GetTimeoutOrDefault(null)); replies.Add(expected.Path); } Assert.Equal(2, replies.Count); var parents = replies.Select(x => x.Parent).Distinct().ToList(); parents.Head().ShouldBe(router.Path); Assert.True(replies.All(x => x.Address.Equals(intendedRemoteAddress))); masterActorSystem.Stop(router); }
public void RemoteRouter_must_deploy_its_children_on_remote_host_driven_by_programmatic_definition() { var probe = CreateTestProbe(masterActorSystem); var router = masterActorSystem.ActorOf(new RemoteRouterConfig(new RoundRobinPool(2), new[] { new Address("akka.tcp", sysName, "localhost", port) }) .Props(Props.Create<Echo>()), "blub2"); var replies = new HashSet<ActorPath>(); for (var i = 0; i < 5; i++) { router.Tell("", probe.Ref); var expected = probe.ExpectMsg<IActorRef>(GetTimeoutOrDefault(null)); replies.Add(expected.Path); } Assert.Equal(2, replies.Count); Assert.Equal(1, replies.Select(x => x.Parent).Distinct().Count()); Assert.True(replies.All(x => x.Address.Equals(intendedRemoteAddress))); masterActorSystem.Stop(router); }
private List<IPackage> GetRootPackagesInDependencyOrder() { var packagesInOrder = new List<IPackage>(); // Get all packages var packages = new HashSet<IPackage>(); foreach (var package in LocalRepository.GetPackages().OrderBy(p => p.Id).ThenByDescending(p => p.Version)) { if (packages.All(p => p.Id != package.Id)) { packages.Add(package); } } while (packages.Count > 0) { var nextPackage = packages.FirstOrDefault(); AddPackageRecursive(packagesInOrder, packages, nextPackage); } return packagesInOrder; }
/// <summary> /// Returns a sequence of ModulePaths for all modules importable from /// the specified library. /// </summary> public static IEnumerable<ModulePath> GetModulesInLib( string interpreterPath, string libraryPath, string sitePath = null, bool requireInitPyFiles = true ) { if (File.Exists(interpreterPath)) { interpreterPath = Path.GetDirectoryName(interpreterPath); } if (!Directory.Exists(libraryPath)) { return Enumerable.Empty<ModulePath>(); } if (string.IsNullOrEmpty(sitePath)) { sitePath = Path.Combine(libraryPath, "site-packages"); } var pthDirs = ExpandPathFiles(sitePath); var excludedPthDirs = new HashSet<string>() { sitePath, libraryPath }; // Get modules in stdlib var modulesInStdLib = GetModulesInPath(libraryPath, true, true, requireInitPy: requireInitPyFiles); // Get files in site-packages var modulesInSitePackages = GetModulesInPath(sitePath, true, false, requireInitPy: requireInitPyFiles); // Get directories in site-packages // This is separate from getting files to ensure that each package // gets its own library path. var packagesInSitePackages = GetModulesInPath(sitePath, false, true, requireInitPy: requireInitPyFiles); // Get modules in DLLs directory IEnumerable<ModulePath> modulesInDllsPath; // Get modules in interpreter directory IEnumerable<ModulePath> modulesInExePath; if (Directory.Exists(interpreterPath)) { modulesInDllsPath = GetModulesInPath(Path.Combine(interpreterPath, "DLLs"), true, false); modulesInExePath = GetModulesInPath(interpreterPath, true, false); excludedPthDirs.Add(interpreterPath); excludedPthDirs.Add(Path.Combine(interpreterPath, "DLLs")); } else { modulesInDllsPath = Enumerable.Empty<ModulePath>(); modulesInExePath = Enumerable.Empty<ModulePath>(); } // Get directories referenced by pth files var modulesInPath = GetModulesInPath( pthDirs.Where(p1 => excludedPthDirs.All(p2 => !PathUtils.IsSameDirectory(p1, p2))), true, true, requireInitPy: requireInitPyFiles ); return modulesInPath .Concat(modulesInDllsPath) .Concat(modulesInStdLib) .Concat(modulesInExePath) .Concat(modulesInSitePackages) .Concat(packagesInSitePackages); }
public void RemoteRouter_must_deploy_its_children_on_remote_host_driven_by_configuration() { var probe = CreateTestProbe(masterActorSystem); var router = masterActorSystem.ActorOf(new RoundRobinPool(2).Props(Props.Create<Echo>()), "blub"); var replies = new HashSet<ActorPath>(); for (var i = 0; i < 5; i++) { router.Tell("", probe.Ref); var expected = probe.ExpectMsg<ActorRef>(); replies.Add(expected.Path); } Assert.Equal(2, replies.Count); Assert.Equal(1, replies.Select(x => x.Parent).Distinct().Count()); Assert.True(replies.All(x => x.Address.Equals(intendedRemoteAddress))); masterActorSystem.Stop(router); }
public void RemoteRouter_must_let_remote_deployment_router_be_overriden_by_local_configuration() { var probe = CreateTestProbe(masterActorSystem); var router = masterActorSystem.ActorOf(new RoundRobinPool(2).Props(Props.Create<Echo>()) .WithDeploy( new Deploy(new RemoteScope(intendedRemoteAddress.Copy()))), "local-blub2"); // This line was subject to a bug in the original Akka - this router should be locally-deployed. router.Path.Address.ToString().ShouldBe(string.Format("akka://{0}", masterActorSystem.Name)); var replies = new HashSet<ActorPath>(); for (var i = 0; i < 5; i++) { router.Tell("", probe.Ref); var expected = probe.ExpectMsg<ActorRef>(); replies.Add(expected.Path); } Assert.Equal(4, replies.Count); var parents = replies.Select(x => x.Parent).Distinct().ToList(); parents.Head().Address.ShouldBe(new Address("akka.tcp", sysName, "localhost", port)); Assert.True(replies.All(x => x.Address.Equals(intendedRemoteAddress))); masterActorSystem.Stop(router); }
public void RemoteRouter_must_deploy_remote_routers_based_on_configuration() { var probe = CreateTestProbe(masterActorSystem); var router = masterActorSystem.ActorOf(Props.Create<Echo>().WithRouter(FromConfig.Instance), "remote-blub"); router.Path.Address.ShouldBe(intendedRemoteAddress); var replies = new HashSet<ActorPath>(); for (var i = 0; i < 5; i++) { router.Tell("", probe.Ref); var expected = probe.ExpectMsg<ActorRef>(); replies.Add(expected.Path); } Assert.Equal(2, replies.Count); var parents = replies.Select(x => x.Parent).Distinct().ToList(); parents.Head().ShouldBe(router.Path); Assert.True(replies.All(x => x.Address.Equals(intendedRemoteAddress))); masterActorSystem.Stop(router); }
// Looks up a member of given name and arity in a particular type. private LookupResult MemberLookup(TypeSymbol type, string name, int arity, bool invoked) { LookupResult result; switch (type.TypeKind) { case TypeKind.RefType: return MemberLookup(((RefTypeSymbol)type).ReferencedType, name, arity, invoked); case TypeKind.TypeParameter: result = MemberLookupInTypeParameter(type, name, arity, invoked); break; case TypeKind.Interface: result = MemberLookupInInterface(type, name, arity, invoked); break; case TypeKind.Class: case TypeKind.Struct: case TypeKind.Enum: case TypeKind.Delegate: case TypeKind.ArrayType: result = MemberLookupInClass(type, name, arity, invoked); break; case TypeKind.Error: case TypeKind.PointerType: return LookupResult.Empty; case TypeKind.Unknown: default: Debug.Fail("Unknown type kind"); return LookupResult.Empty; } // TODO: Diagnose ambiguity problems here, and conflicts between non-method and method? Or is that // done in the caller? return result; #if SLOW // A member lookup is the process whereby the meaning of a name in the context of // a type is determined. A member lookup can occur as part of evaluating a // simple-name or a member-access in an expression. If the // simple-name or member-access occurs as the simple-expression of an // invocation-expression, the member is said to be invoked. // If a member is a method or event, or if it is a constant, field or property // of a delegate type, then the member is said to be invocable. // Member lookup considers not only the name of a member but also the number of // type parameters the member has and whether the member is accessible. For the // purposes of member lookup, generic methods and nested generic types have the // number of type parameters indicated in their respective declarations and all // other members have zero type parameters. // A member lookup of a name N with K type parameters in a type T is processed as follows: // First, a set of accessible members named N is determined. // If T is a type parameter, then the set is the union of the sets of accessible // members named N in each of the types specified as a primary constraint or secondary // constraint for T, along with the set of accessible members named N in object. // Otherwise, the set consists of all accessible members named N in T, // including inherited members and the accessible members named N in object. If T is // a constructed type, the set of members is obtained by substituting type arguments // as described in §10.3.2. Members that include an override modifier are excluded // from the set. var results = new HashSet<Symbol>(); var inaccessible = new HashSet<Symbol>(); var notInvocable = new HashSet<Symbol>(); var hidden1 = new HashSet<Symbol>(); var hidden2 = new HashSet<Symbol>(); var types = new HashSet<TypeSymbol>(type.TypeAndAllBaseTypes()); types.Add(System_Object); foreach (TypeSymbol t in types) { results.UnionWith( from s in t.GetMembers(name) where !s.IsOverride select s); } inaccessible.UnionWith(from s in results where !IsMemberAccessible(s) select s); results.ExceptWith(inaccessible); var badArity = new HashSet<Symbol>(); // Next, if K is zero, all nested types whose declarations include type parameters are removed. // If K is not zero, all members with a different number of type parameters are removed. // Note that when K is zero, methods having type parameters are not removed, since the // type inference process might be able to infer the type arguments. if (arity == 0) { badArity.UnionWith(from s in results where s.IsNestedType() && ((NamedTypeSymbol)s).Arity != 0 select s); } else { badArity.UnionWith(from s in results where s is NamedTypeSymbol && ((NamedTypeSymbol)s).Arity != arity select s); badArity.UnionWith(from s in results where s is MethodSymbol && ((MethodSymbol)s).TypeParameters.Count != arity select s); } results.ExceptWith(badArity); // Next, if the member is invoked, all non-invocable members are removed from the set. if (invoked) { notInvocable.UnionWith(from s in results where !IsInvocable(s) select s); } results.ExceptWith(notInvocable); // Next, members that are hidden by other members are removed from the set. // For every member S.M in the set, where S is the type in which the member M is declared, // the following rules are applied: foreach (var member in results) { var declaringType = member.ContainingType; // If M is a constant, field, property, event, or enumeration member, // then all members declared in a base type of S are removed from the set. if (member is FieldSymbol || member is PropertySymbol /* UNDONE || member is EventSymbol */) { foreach (var baseType in declaringType.AllBaseTypeDefinitions()) { hidden1.UnionWith( from s in results where s.ContainingType.OriginalDefinition == baseType select s); } } else if (member is NamedTypeSymbol) { // If M is a type declaration, then all non-types declared in a base type of S // are removed from the set, and all type declarations with the same number of // type parameters as M declared in a base type of S are removed from the set. foreach (var baseType in declaringType.AllBaseTypeDefinitions()) { hidden1.UnionWith( from s in results where s.ContainingType.OriginalDefinition == baseType where !(s is NamedTypeSymbol) || ((NamedTypeSymbol)s).Arity == ((NamedTypeSymbol)member).Arity select s); } } else if (member is MethodSymbol) { // If M is a method, then all non-method members declared in a base type of S // are removed from the set. foreach (var baseType in declaringType.AllBaseTypeDefinitions()) { hidden1.UnionWith( from m in results where m.ContainingType.OriginalDefinition == baseType && !(m is MethodSymbol) select m); } } } results.ExceptWith(hidden1); // Next, interface members that are hidden by class members are removed from the set. // This step only has an effect if T is a type parameter and T has both an effective base // class other than object and a non-empty effective interface set. For every // member S.M in the set, where S is the type in which the member M is declared, the // following rules are applied if S is a class declaration other than object: foreach (var member in results) { var declaringType = member.ContainingType; if (!declaringType.IsClassType() || declaringType == System_Object) { continue; } // If M is a constant, field, property, event, enumeration member, or type declaration, // then all members declared in an interface declaration are removed from the set. if (member is FieldSymbol || member is PropertySymbol /* UNDONE || member is EventSymbol */ || member is NamedTypeSymbol) { hidden2.UnionWith( from m in results where m.ContainingType.IsInterfaceType() select m); } else if (member is MethodSymbol) { // If M is a method, then all non-method members declared in an interface declaration // are removed from the set, and all methods with the same signature as M declared // in an interface declaration are removed from the set. hidden2.UnionWith( from m in results where m.ContainingType.IsInterfaceType() && (!(m is MethodSymbol) || HaveSameSignature((MethodSymbol)m, (MethodSymbol)member)) select m); } } results.ExceptWith(hidden2); hidden1.UnionWith(hidden2); // Finally, having removed hidden members, the result of the lookup is determined: // If the set consists of a single member that is not a method, then this member is the result of the lookup. // Otherwise, if the set contains only methods, then this group of methods is the result of the lookup. // Otherwise, the lookup is ambiguous, and a compile-time error occurs. // For member lookups in types other than type parameters and interfaces, and member lookups in interfaces // that are strictly single-inheritance (each interface in the inheritance chain has exactly zero or one direct // base interface), the effect of the lookup rules is simply that derived members hide base members with the // same name or signature. Such single-inheritance lookups are never ambiguous. The ambiguities that can possibly // arise from member lookups in multiple-inheritance interfaces are described in §13.2.5. // UNDONE: Make this match what the original compiler does. if (results.Count == 0 || (results.Count > 1 && !results.All(m => m is MethodSymbol))) { if (inaccessible.Count != 0) { return LookupResult.Inaccessible(inaccessible.First()); } else if (badArity.Count != 0) { return LookupResult.WrongArity(badArity.First(), null); } else { return LookupResult.Bad((DiagnosticInfo)null); } } else { return LookupResult.ForSymbols(results); } #endif }
internal override FunctionUpdateCommand Translate( UpdateTranslator translator, ExtractedStateEntry stateEntry) { var mapping = GetFunctionMapping(stateEntry); StorageEntityTypeModificationFunctionMapping typeMapping = mapping.Item1; StorageModificationFunctionMapping functionMapping = mapping.Item2; EntityKey entityKey = stateEntry.Source.EntityKey; var stateEntries = new HashSet<IEntityStateEntry> { stateEntry.Source }; // gather all referenced association ends var collocatedEntries = // find all related entries corresponding to collocated association types from end in functionMapping.CollocatedAssociationSetEnds join candidateEntry in translator.GetRelationships(entityKey) on end.CorrespondingAssociationEndMember.DeclaringType equals candidateEntry.EntitySet.ElementType select Tuple.Create(end.CorrespondingAssociationEndMember, candidateEntry); var currentReferenceEnds = new Dictionary<AssociationEndMember, IEntityStateEntry>(); var originalReferenceEnds = new Dictionary<AssociationEndMember, IEntityStateEntry>(); foreach (var candidate in collocatedEntries) { ProcessReferenceCandidate(entityKey, stateEntries, currentReferenceEnds, originalReferenceEnds, candidate.Item1, candidate.Item2); } // create function object FunctionUpdateCommand command; // consider the following scenario, we need to loop through all the state entries that is correlated with entity2 and make sure it is not changed. // entity1 <-- Independent Association <-- entity2 <-- Fk association <-- entity 3 // | // entity4 <-- Fk association <-- if (stateEntries.All(e => e.State == EntityState.Unchanged)) { // we shouldn't update the entity if it is unchanged, only update when referenced association is changed. // if not, then this will trigger a fake update for principal end as describe in bug 894569. command = null; } else { command = new FunctionUpdateCommand(functionMapping, translator, stateEntries.ToList().AsReadOnly(), stateEntry); // bind all function parameters BindFunctionParameters(translator, stateEntry, functionMapping, command, currentReferenceEnds, originalReferenceEnds); // interpret all result bindings if (null != functionMapping.ResultBindings) { foreach (StorageModificationFunctionResultBinding resultBinding in functionMapping.ResultBindings) { PropagatorResult result = stateEntry.Current.GetMemberValue(resultBinding.Property); command.AddResultColumn(translator, resultBinding.ColumnName, result); } } } return command; }
//if the activities has any relation where they are the target and the source is not in activities private static bool HasIngoingConnections(DcrGraph graph, HashSet<Activity> activities) => graph.IncludeExcludes.Any(keyValuePair => activities.All(a => !Equals(a, keyValuePair.Key)) && activities.Any(a => keyValuePair.Value.ContainsKey(a))) || graph.Conditions.Any(keyValuePair => activities.All(a => !Equals(a, keyValuePair.Key)) && activities.Any(a => keyValuePair.Value.Contains(a))) || graph.Responses.Any(keyValuePair => activities.All(a => !Equals(a, keyValuePair.Key)) && activities.Any(a => keyValuePair.Value.Contains(a))) || graph.Milestones.Any(keyValuePair => activities.All(a => !Equals(a, keyValuePair.Key)) && activities.Any(a => keyValuePair.Value.Contains(a)));
public static void Main(string[] args) { if (args.Count() != 6) { Console.WriteLine("usage DependencyDumper assemblyFolder assemblyName typePattern minDepth roots absoluteOutputPath"); Console.WriteLine("you provided: " + Environment.CommandLine); Console.ReadLine(); return; } string assemblyFolder = args[0]; string assemblyName = args[1]; Regex typePattern = new Regex(args[2]); int minDepth = int.Parse(args[3]); string[] roots = string.IsNullOrEmpty(args[4]) ? new string[] { } : args[4].Split(','); string outputPath = args[5]; RegisterAssemblyResolveHandler(assemblyFolder); types = new HashSet<Type>(); dependencies = new HashSet<Tuple<Type, Type>>(); allTypes = new HashSet<Type>(); Console.WriteLine("dumping dependencies of " + assemblyName + " and all its referenced assemblies."); Console.WriteLine("using assemblies from folder " + assemblyFolder); Console.WriteLine("using only types matching " + typePattern); Console.WriteLine("dumping only dependency chains longer or equal to " + minDepth); Console.WriteLine("treating the following classes as roots (even if they are used by other classes): " + string.Join(", ", roots)); Console.WriteLine("writing output to (should be a .tgf file)" + outputPath); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("loading types from assemblies..."); Assembly assembly = Assembly.LoadFrom(Path.Combine(assemblyFolder, assemblyName)); var allAssemblies = new List<Assembly>(); AddAssemblies(assembly, allAssemblies); foreach (var a in allAssemblies) { var t = a.GetTypes(); foreach (var type in t) { if (typePattern.IsMatch(type.FullName)) { if (!type.Name.Contains("__")) { allTypes.Add(type); } } } } Console.WriteLine(); Console.WriteLine("processing types:"); foreach (Type type in allTypes) { Console.WriteLine("processing type " + type.FullName); Step(type); } // explicit roots Console.WriteLine(); Console.WriteLine("processing explicit roots:"); foreach (string root in roots) { Console.WriteLine("removing dependencies on " + root); var regex = new Regex(root); var toBreak = dependencies.Where(t => t.Item2.FullName != null && regex.IsMatch(t.Item2.FullName)).ToList(); foreach (Tuple<Type, Type> tuple in toBreak) { dependencies.Remove(tuple); } } Console.WriteLine(); Console.WriteLine("calculating dependency depths"); Dictionary<Type, int> levels = CalculateNodeDepth(); Console.WriteLine(); Console.WriteLine("removing types that are not in a deep enough dependency chain:"); List<Type> remove = new List<Type>(); do { remove.Clear(); foreach (Type type in types) { // root type and not enough depth if (dependencies.All(t => t.Item2 != type) && levels[type] < minDepth) { remove.Add(type); } } foreach (Type type in remove) { Console.WriteLine("removing type " + type); types.Remove(type); dependencies.RemoveWhere(t => t.Item1 == type); } } while (remove.Count > 0); Console.WriteLine(); Console.WriteLine("writing output file..."); var list = new List<Type>(types); using (StreamWriter writer = new StreamWriter(outputPath)) { foreach (var type in list) { var i = levels.ContainsKey(type) ? levels[type] : 0; writer.WriteLine(new List<Type>(types).IndexOf(type) + " " + type.NameToString() + " " + i); } writer.WriteLine("#"); foreach (var dependency in dependencies) { if (list.IndexOf(dependency.Item1) >= 0 && list.IndexOf(dependency.Item2) >= 0) { writer.WriteLine( list.IndexOf(dependency.Item1) + " " + list.IndexOf(dependency.Item2)); } } } Console.WriteLine(); Console.WriteLine(@"opening yEd (C:\Program Files (x86)\yWorks\yEd\yEd.exe)"); Process yEd = new Process { StartInfo = { FileName = @"C:\Program Files (x86)\yWorks\yEd\yEd.exe", Arguments = outputPath } }; yEd.Start(); Console.WriteLine("done. Output file is at " + outputPath); }
private static bool AllOrNoneInThisSet(HashSet<Activity> activities, HashSet<Activity> set) => activities.All(set.Contains) || !set.Any(activities.Contains);
public void Execute() { //We only want to run the base query once, so we capture all of the facet-ing terms then run the query // once through the collector and pull out all of the terms in one shot var allCollector = new GatherAllCollector(); var facetsByName = new Dictionary<string, Dictionary<string, FacetValue>>(); using (var currentState = Database.IndexStorage.GetCurrentStateHolder(Index)) { var currentIndexSearcher = currentState.IndexSearcher; var baseQuery = Database.IndexStorage.GetLuceneQuery(Index, IndexQuery, Database.IndexQueryTriggers); currentIndexSearcher.Search(baseQuery, allCollector); var fields = Facets.Values.Select(x => x.Name) .Concat(Ranges.Select(x => x.Key)); var fieldsToRead = new HashSet<string>(fields); FieldTermVector fieldTermVector; var allVectoredTerms = fieldsToRead.All(s => indexDefinition.TermVectors.TryGetValue(s, out fieldTermVector) && fieldTermVector != FieldTermVector.No); if (allVectoredTerms) { IndexedTerms.ReadEntriesForFieldsFromTermVectors(currentState, fieldsToRead, allCollector.Documents, (field,value, doc) => HandleFacets(field,value, facetsByName, doc)); } else { IndexedTerms.ReadEntriesForFields(currentState, fieldsToRead, allCollector.Documents, (field, value, doc) => HandleFacets(field,value, facetsByName, doc)); } UpdateFacetResults(facetsByName); CompleteFacetCalculationsStage1(currentState, allVectoredTerms); CompleteFacetCalculationsStage2(); } }
private static void EnsureFieldsAreInCache(IndexSearcherHolder.IndexSearcherHoldingState state, HashSet<string> fieldsToRead, IndexReader reader) { if (fieldsToRead.All(state.IsInCache)) return; state.Lock.ExitReadLock(); state.Lock.EnterWriteLock(); try { var fieldsNotInCache = fieldsToRead.Where(field => state.IsInCache(field) == false).ToList(); if (fieldsToRead.Count > 0) FillCache(state, fieldsNotInCache, reader); } finally { state.Lock.ExitWriteLock(); } state.Lock.EnterReadLock(); }
/// <summary> /// Build a dictionary of mixins /// </summary> /// <param name="finalMixins">a list of mixins</param> /// <returns>a dictionary of all the necessary mixins</returns> private Dictionary<string, ModuleMixin> BuildMixinDictionary(IEnumerable<ModuleMixin> finalMixins) { var allMixins = new HashSet<ModuleMixin>(); foreach (var mixin in finalMixins) { if (allMixins.All(x => x.MixinName != mixin.MixinName)) allMixins.Add(mixin); } return allMixins.ToDictionary(x => x.MixinName, x => x); }
/// <summary> /// Unite filename casing between git index and host OS /// </summary> /// <param name="repo"></param> /// <param name="gitPathInfo"></param> /// <param name="folders"></param> private static void UniteFilenameCasing(this UniteRepository repo, DirectoryInfo gitPathInfo, List<DirectoryInfo> folders) { var files = folders.GetAllFileInfos(gitPathInfo); var filesFullPathMap = new HashSet<String>(files.ConvertAll(s => s.FullName)); var indexFileEntries = repo.Index.Where(f => filesFullPathMap.All(s => s.Replace(repo.Info.WorkingDirectory, string.Empty) != f.Path)); foreach (var entry in indexFileEntries) { var sourcePath = repo.Info.WorkingDirectory + entry.Path; // Match host OS filename based on full pathname ignoring case var target = files.FirstOrDefault(f => String.Equals(f.FullName, sourcePath, StringComparison.CurrentCultureIgnoreCase)); if (target == null) continue; // Unite the git index with the correct OS folder repo.Unite(sourcePath, target.FullName); } }
/// <summary> /// Combines several collections of <see cref="IPHostEntry"/> objects into one deduplicated list /// </summary> /// <param name="collections">Collections to combine</param> /// <returns>Deduplicated list of <see cref="IPHostEntry"/> objects</returns> private static ICollection<IPHostEntry> Combine(IEnumerable<ICollection<IPHostEntry>> collections) { var result = new HashSet<IPHostEntry>(); if (collections == null) return result; foreach (var collection in collections.Where(collection => collection != null)) foreach (var host in collection.Where(host => host != null)) { if (String.IsNullOrEmpty(host.HostName)) { if (host.AddressList == null || !host.AddressList.Any()) continue; // We only have one or more IP addresses - no HostName. We consider this host the same as a host we // already have in our result, when at least one IP address in this host equals one IP address of the result host. host.HostName = String.Empty; host.AddressList = host.AddressList.Where(address => address != null).ToArray(); var alreadyPresentHost = result.FirstOrDefault(presentHost => presentHost.AddressList.Intersect(host.AddressList).Any()); if (alreadyPresentHost == null) result.Add(host); else alreadyPresentHost.AddressList = alreadyPresentHost.AddressList.Union(host.AddressList).ToArray(); } else { host.HostName = host.HostName.ToUpperInvariant(); if (host.AddressList == null || !host.AddressList.Any()) { // We only have a HostName - no IP addresses. We consider this host the same as a host we already have in our // result, wenn the HostName is the same host.AddressList = new IPAddress[0]; if (result.All(presentHost => presentHost.HostName != host.HostName)) result.Add(host); } else { // We have both, HostName and one or more IP addresses. // If there is already a host with the same HostName, we combine the IP addresses. // If there is a host with a different HostName, but at least one identical IP address, // if the already present HostName is String.Empty, we replace the empty string with the new HostName // and combine the IP addresses; // if the already present HostName is not String.Empty, we log a warning, // combine the IP addresses of the already present host and discard the HostName of the new host. // If there is no host with the same HostName and no host with one or more identical IP addresses, we // add the new host to the result. host.AddressList = host.AddressList.Where(address => address != null).ToArray(); var alreadyPresentHost = result.FirstOrDefault(presentHost => presentHost.HostName == host.HostName); if (alreadyPresentHost != null) alreadyPresentHost.AddressList = alreadyPresentHost.AddressList.Union(host.AddressList).ToArray(); else { alreadyPresentHost = result.FirstOrDefault(presentHost => presentHost.AddressList.Intersect(host.AddressList).Any()); if (alreadyPresentHost != null) { if (alreadyPresentHost.HostName == String.Empty) { alreadyPresentHost.HostName = host.HostName; alreadyPresentHost.AddressList = alreadyPresentHost.AddressList.Union(host.AddressList).ToArray(); } else { ServiceRegistration.Get<ILogger>().Warn("NeighborhoodBrowserService: Found two computers with different HostNames but at least one identical IP-Address:"); ServiceRegistration.Get<ILogger>().Warn("NeighborhoodBrowserService: HostName: '{0}', IP-Addresses {1}", alreadyPresentHost.HostName, String.Join(" / ", alreadyPresentHost.AddressList.Select(adress => adress.ToString()))); ServiceRegistration.Get<ILogger>().Warn("NeighborhoodBrowserService: HostName: '{0}', IP-Addresses {1}", host.HostName, String.Join(" / ", host.AddressList.Select(adress => adress.ToString()))); ServiceRegistration.Get<ILogger>().Warn("NeighborhoodBrowserService: Discarding the second HostName and adding its IP-Addresses to the first host."); alreadyPresentHost.AddressList = alreadyPresentHost.AddressList.Union(host.AddressList).ToArray(); } } else result.Add(host); } } } } return result; }
private static bool Assignable(HashSet<int> arg) { return arg.All(a => !arg.Contains(-a)); }
public void RemoteRouter_must_deploy_dynamic_resizable_number_of_children_on_remote_host_driven_by_configuration () { var probe = CreateTestProbe(masterActorSystem); var router = masterActorSystem.ActorOf(Props.Create<Echo>().WithRouter(FromConfig.Instance), "elastic-blub"); var replies = new HashSet<ActorPath>(); for (var i = 0; i < 5000; i++) { router.Tell("", probe.Ref); var expected = probe.ExpectMsg<IActorRef>(GetTimeoutOrDefault(null)); replies.Add(expected.Path); } Assert.True(replies.Count >= 2); Assert.Equal(1, replies.Select(x => x.Parent).Distinct().Count()); Assert.True(replies.All(x => x.Address.Equals(intendedRemoteAddress))); masterActorSystem.Stop(router); }
public bool CreatePMRoom(HashSet<int> newUsers, int creator, out string error) { error = ""; bool result = false; lock(managerLock) { Log("Enter createpmroom lock", MyExtensions.Logging.LogLevel.Locks); if (newUsers.Count < 2) { error = "There's not enough people to make the room"; } else if (rooms.Any(x => x.Value.Users.SetEquals(newUsers))) { error = "There's already a room with this exact set of people!"; } else if (!newUsers.All(x => users.ContainsKey(x))) { error = "One or more of the given users doesn't exist!"; } /*else if (newUsers.Any(x => users[x].IrcUser)) { error = "You can't include IRC users in a PM room!"; }*/ else if (!users.ContainsKey(creator)) { error = "You don't seem to exist... I'm not sure how to create the room"; } else if (users[creator].Banned || users[creator].Blocked) { error = "You are banned or blocked and cannot create a room"; } else { PMRoom newRoom = new PMRoom(newUsers, creator, TimeSpan.FromDays(1)); rooms.Add(newRoom.Name, newRoom); result = true; } Log("Exit createpmroom lock", MyExtensions.Logging.LogLevel.Locks); } if (result) BroadcastUserList(); return result; }
public void RemoteRouter_must_let_remote_deployment_be_overridden_by_remote_configuration() { var probe = CreateTestProbe(masterActorSystem); var router = masterActorSystem.ActorOf(new RoundRobinPool(2).Props(Props.Create<Echo>()) .WithDeploy( new Deploy(new RemoteScope(intendedRemoteAddress))), "remote-override"); router.Path.Address.ShouldBe(intendedRemoteAddress); var replies = new HashSet<ActorPath>(); for (var i = 0; i < 5; i++) { router.Tell("", probe.Ref); var expected = probe.ExpectMsg<IActorRef>(GetTimeoutOrDefault(null)); replies.Add(expected.Path); } Assert.Equal(4, replies.Count); var parents = replies.Select(x => x.Parent).Distinct().ToList(); parents.Count.ShouldBe(1); parents.Head().Address.ShouldBe(new Address("akka.tcp", sysName, "localhost", port)); Assert.True(replies.All(x => x.Address.Equals(intendedRemoteAddress))); masterActorSystem.Stop(router); }
public void RemoveWhere() { var set = new HashSet<int>(Enumerable.Range(0, 10)); Assert.That(() => { set.RemoveWhere(null); }, Throws.TypeOf(typeof(ArgumentNullException))); set.RemoveWhere(i => i % 2 == 0); Assert.AreEqual(5, set.Count); Assert.IsTrue(set.All(i => i % 2 == 1)); }