public HashSet<CartItem> Get(CartItemBasedDiscountApplication application, CartModel cart)
 {
     var cartItems = new HashSet<CartItem>();
     cartItems.AddRange(_getCartItemsBySKUList.GetCartItems(cart, application.SKUs));
     cartItems.AddRange(_getCartItemsByCategoryIdList.GetCartItems(cart, application.CategoryIds));
     return cartItems;
 }
Example #2
0
        private RenameLocationSet(ISymbol symbol, Solution solution, OptionSet optionSet, SearchResult originalSymbolResult, List<SearchResult> overloadsResult, IEnumerable<RenameLocation> stringsResult, IEnumerable<RenameLocation> commentsResult)
        {
            _symbol = symbol;
            _solution = solution;
            _optionSet = optionSet;
            _originalSymbolResult = originalSymbolResult;
            _overloadsResult = overloadsResult;
            _stringsResult = stringsResult;
            _commentsResult = commentsResult;

            var mergedLocations = new HashSet<RenameLocation>();
            var mergedReferencedSymbols = new List<ISymbol>();
            var mergedImplicitLocations = new List<ReferenceLocation>();

            if (optionSet.GetOption(RenameOptions.RenameInStrings))
            {
                mergedLocations.AddRange(stringsResult);
            }

            if (optionSet.GetOption(RenameOptions.RenameInComments))
            {
                mergedLocations.AddRange(commentsResult);
            }

            var overloadsToMerge = (optionSet.GetOption(RenameOptions.RenameOverloads) ? overloadsResult : null) ?? SpecializedCollections.EmptyEnumerable<SearchResult>();
            foreach (var result in overloadsToMerge.Concat(originalSymbolResult))
            {
                mergedLocations.AddRange(result.Locations);
                mergedImplicitLocations.AddRange(result.ImplicitLocations);
                mergedReferencedSymbols.AddRange(result.ReferencedSymbols);
            }

            _mergedResult = new SearchResult(mergedLocations, mergedImplicitLocations, mergedReferencedSymbols);
        }
        protected override void ProcessAssembly(AssemblyDefinition assemblyDef)
        {
            if (_frameworkProfile == null) {
                _frameworkProfile = assemblyDef.GuessAssemblyProfile();
            }
            if (_frameworkProfile != null) {
                _assemblyResolver.AddSearchDirectory(_frameworkProfile.ReferencesDirectory);
            }
            var typesDependenciesCollector = new CollectTypesDependenciesProcessor(_frameworkProfile);
            typesDependenciesCollector.Process(assemblyDef);

            var goodAssemblyNames = assemblyDef.Modules.SelectMany(asmDef => asmDef.AssemblyReferences);
            if(_removeNonRetargetable) {
                goodAssemblyNames = goodAssemblyNames.Where(asmRef => asmRef.IsRetargetable);
            }
            if (_frameworkProfile != null) {
                goodAssemblyNames = goodAssemblyNames.Concat(_frameworkProfile.GetFrameworkAssemblies());
            }

            var goodModules = new HashSet<ModuleDefinition>(CecilEqualityComparer.Default);
            goodModules.AddRange(assemblyDef.Modules);
            goodModules.AddRange(goodAssemblyNames.Select(_assemblyResolver.TryResolve).Where(asmDef => asmDef != null).SelectMany(asmDef => asmDef.Modules));

            var allTypesDependencies = typesDependenciesCollector.AllTypesDependencies;
            var typeDependenciesToRemove = new Queue<TypeReferenceAndDependencies>(allTypesDependencies.Where(
                kv => {
                    var typeRef = kv.Key;
                    var typeDef = typeRef.TryResolve();
                    return typeDef == null || !goodModules.Contains(typeDef.Module);
                }).Select(kv => (TypeReferenceAndDependencies)kv));

            var removedDependencies = new HashSet<TypeDependency>();
            while (typeDependenciesToRemove.Any()) {
                var typeDependencies = typeDependenciesToRemove.Dequeue();
                var typeRef = typeDependencies.Type;
                var dependencies = typeDependencies.DependingMembers;
                Trace.WriteLine(string.Format("Removing dependencies on type {0}:", typeRef), "RemoveExternalTypesUsage");
                Trace.Indent();
                foreach (var dependency in dependencies) {
                    if (!removedDependencies.Contains(dependency)) {
                        dependency.Break();
                        removedDependencies.Add(dependency);

                        var baseClassDependency = dependency as BaseClassDependency;
                        if (baseClassDependency != null) {
                            var removedClass = baseClassDependency.DerivedClass;
                            if (allTypesDependencies.ContainsKey(removedClass)) {
                                var removedClassDependencies = allTypesDependencies[removedClass];
                                typeDependenciesToRemove.Enqueue(new TypeReferenceAndDependencies(removedClass, removedClassDependencies));
                            }
                        }
                    }
                }
                Trace.Unindent();
            }

            base.ProcessAssembly(assemblyDef);
        }
        private static IEnumerable<string> Edits(string word)
        {
            var set = new HashSet<string>();

            var splits = Splits(set, word);
            set.AddRange(Deletes(splits));
            set.AddRange(Transposes(splits));
            set.AddRange(Replaces(splits));
            set.AddRange(Inserts(splits));

            return set;
        }
        public void Grant(params string[] permissions)
        {
            if (permissions == null || permissions.Length == 0)
                throw new ArgumentNullException(nameof(permissions));

            var grantingStack = GetGrantingStack(true);

            if (grantingStack.Count > 0)
            {
                var oldSet = grantingStack.Peek();
                if (oldSet == null)
                {
                    grantingStack.Push(null);
                }
                else
                {
                    var newSet = new HashSet<string>(oldSet);
                    newSet.AddRange(permissions);
                    grantingStack.Push(newSet);
                }
            }
            else
            {
                grantingStack.Push(new HashSet<string>(permissions));
            }
        }
Example #6
0
        public void UpdateLayout()
        {
            HashSet<UIElement> arrangedElements = new HashSet<UIElement>();

            while (measureQueue.Count > 0 || arrangeQueue.Count > 0)
            {
                while (measureQueue.Count > 0)
                {
                    UIElement element = GetTopElement(measureQueue);
                    element.Measure(element.VisualParent == null || element.PreviousAvailableSize.IsEmpty ? Size.Infinity : element.PreviousAvailableSize);
                }

                arrangedElements.AddRange(arrangeQueue.SelectMany(element => GetElementPath(element)));

                while (arrangeQueue.Count > 0)
                {
                    UIElement element = GetTopElement(arrangeQueue);
                    element.Arrange(element.VisualParent == null || element.PreviousFinalRect.IsEmpty ? new Rect(element.DesiredSize) : element.PreviousFinalRect);
                }

                while (arrangedElements.Count > 0 && measureQueue.Count == 0 && arrangeQueue.Count == 0) // LayoutUpdated can invalidate other elements
                {
                    UIElement element = arrangedElements.First();
                    arrangedElements.Remove(element);

                    element.RaiseLayoutUpdated();
                }
            }
        }
Example #7
0
        /// <summary>
        /// Gets the application assemblies.
        /// </summary>
        /// <param name="assemblyFilter">(Optional) A filter for the assemblies.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A promise of an enumeration of application assemblies.
        /// </returns>
        public virtual async Task<IEnumerable<Assembly>> GetAppAssembliesAsync(Func<AssemblyName, bool> assemblyFilter = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            // TODO The assemblies from the current domain do not consider the not loaded
            // but required referenced assemblies. Therefore load all the references recursively.
            // This could be optimized somehow.
            var assemblies = this.GetLoadedAssemblies();

            assemblyFilter = assemblyFilter ?? this.AssemblyFilter;
            var loadedAssemblyRefs = new HashSet<string>(assemblies.Select(a => a.GetName().FullName));
            var assembliesToCheck = assemblies.Where(a => assemblyFilter(a.GetName())).ToList();

            while (assembliesToCheck.Count > 0)
            {
                var assemblyRefsToLoad = new HashSet<AssemblyName>();
                foreach (var assembly in assembliesToCheck)
                {
                    var referencesToLoad = this.GetReferencedAssemblies(assembly).Where(a => !loadedAssemblyRefs.Contains(a.FullName) && assemblyFilter(a));
                    assemblyRefsToLoad.AddRange(referencesToLoad);
                }

                loadedAssemblyRefs.AddRange(assemblyRefsToLoad.Select(an => an.FullName));
                assembliesToCheck = assemblyRefsToLoad.Select(this.AssemblyLoader.LoadAssembly).ToList();
                assemblies.AddRange(assembliesToCheck);
            }

            await this.AddAdditionalAssembliesAsync(assemblies, assemblyFilter, cancellationToken).PreserveThreadContext();
            return assemblies;
        }
        public HashSet<string> GetAllAvailableLocalTextKeys()
        {
            var result = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (var assembly in ExtensibilityHelper.SelfAssemblies)
            {
                foreach (NavigationItemAttribute attr in assembly.GetCustomAttributes(typeof(NavigationItemAttribute), false))
                    result.Add("Navigation." + (attr.Category.IsEmptyOrNull() ? "" : attr.Category + "/") + attr.Title);

                foreach (var type in assembly.GetTypes())
                {
                    var attr = type.GetCustomAttribute<FormScriptAttribute>();
                    if (attr != null)
                    {
                        foreach (var member in type.GetMembers(BindingFlags.Instance | BindingFlags.Public))
                        {
                            var category = member.GetCustomAttribute<CategoryAttribute>();
                            if (category != null && !category.Category.IsEmptyOrNull())
                                result.Add("Forms." + attr.Key + ".Categories." + category.Category);
                        }
                    }
                }
            }

            var repository = Dependency.Resolve<ILocalTextRegistry>() as LocalTextRegistry;
            if (repository != null)
                result.AddRange(repository.GetAllTextKeys(false));

            return result;
        }
		void UpdateCompilerComboBox()
		{
			if (listView.SelectedItems.Count > 0) {
				// Fetch list of available compiler versions
				HashSet<CompilerVersion> availableVersionsSet = new HashSet<CompilerVersion>();
				HashSet<CompilerVersion> currentVersions = new HashSet<CompilerVersion>();
				foreach (Entry entry in listView.SelectedItems) {
					if (entry.CompilerVersion != null)
						currentVersions.Add(entry.CompilerVersion);
					availableVersionsSet.AddRange(entry.Project.GetAvailableCompilerVersions());
				}
				List<CompilerVersion> availableVersions = availableVersionsSet.OrderBy(n => n.MSBuildVersion).ThenBy(n => n.DisplayName).ToList();
				if (currentVersions.Count != 1) {
					availableVersions.Insert(0, new UnchangedCompilerVersion());
				}
				// Assign available versions to newVersionComboBox
				// Unless the user has already chosen a version, automatically set the selection to the
				// current version of the chosen projects, or to 'do not change' if there are different
				// current versions.
				newCompilerSelectionChangingByCode = true;
				newVersionComboBox.ItemsSource = availableVersions;
				
				CompilerVersion oldSelectedVersion = newVersionComboBox.SelectedValue as CompilerVersion;
				if (!newCompilerSelectionSetByUser || oldSelectedVersion == null) {
					newCompilerSelectionSetByUser = false;
					if (currentVersions.Count == 1)
						newVersionComboBox.SelectedValue = currentVersions.Single();
					else
						newVersionComboBox.SelectedValue = new UnchangedCompilerVersion();
				}
				newCompilerSelectionChangingByCode = false;
				UpdateTargetFrameworkComboBox();
			}
		}
Example #10
0
 static ClientTypesGenerator()
 {
     lookupEditorBaseOptions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
     lookupEditorBaseOptions.AddRange(typeof(LookupEditorBaseAttribute)
         .GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
         .Select(x => x.Name));
 }
		static void FindDerivedClasses(HashSet<IClass> resultList, IClass baseClass, IEnumerable<IProjectContent> projectContents, bool directDerivationOnly)
		{
			baseClass = baseClass.GetCompoundClass();
			string baseClassName = baseClass.Name;
			string baseClassFullName = baseClass.FullyQualifiedName;
			LoggingService.Debug("FindDerivedClasses for " + baseClassFullName);
			List<IClass> list = new List<IClass>();
			foreach (IProjectContent pc in projectContents) {
				if (pc != baseClass.ProjectContent && !pc.ReferencedContents.Contains(baseClass.ProjectContent)) {
					// only project contents referencing the content of the base class
					// can derive from the class
					continue;
				}
				AddDerivedClasses(pc, baseClass, baseClassName, baseClassFullName, pc.Classes, list);
			}
			if (directDerivationOnly) {
				resultList.AddRange(list);
			} else {
				foreach (IClass c in list) {
					if (resultList.Add(c)) {
						FindDerivedClasses(resultList, c, projectContents, directDerivationOnly);
					}
				}
			}
		}
        public async Task<Document> AddImportsAsync(Document document, IEnumerable<TextSpan> spans, OptionSet options, CancellationToken cancellationToken)
        {
            options = options ?? document.Project.Solution.Workspace.Options;

            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
            var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);

            // Create a simple interval tree for simplification spans.
            var spansTree = new SimpleIntervalTree<TextSpan>(TextSpanIntervalIntrospector.Instance, spans);

            Func<SyntaxNodeOrToken, bool> isInSpan = (nodeOrToken) =>
                spansTree.GetOverlappingIntervals(nodeOrToken.FullSpan.Start, nodeOrToken.FullSpan.Length).Any();

            var nodesWithExplicitNamespaces = root.DescendantNodesAndSelf().Where(n => isInSpan(n) && GetExplicitNamespaceSymbol(n, model) != null).ToList();

            var namespacesToAdd = new HashSet<INamespaceSymbol>();
            namespacesToAdd.AddRange(nodesWithExplicitNamespaces.Select(n => GetExplicitNamespaceSymbol(n, model)));

            // annotate these nodes so they get simplified later
            var newRoot = root.ReplaceNodes(nodesWithExplicitNamespaces, (o, r) => r.WithAdditionalAnnotations(Simplifier.Annotation));
            var newDoc = document.WithSyntaxRoot(newRoot);
            var newModel = await newDoc.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            newRoot = await this.AddNamespaceImportsAsync(newDoc, newModel, options, namespacesToAdd, cancellationToken).ConfigureAwait(false);
            return document.WithSyntaxRoot(newRoot);
        }
Example #13
0
 public ActorId[] Get(ActorId id)
 {
     lock (creatorToOther)
     {
         var actors = new HashSet<ActorId>();
         List<ActorId> a;
         foreach (var alias in DnsAlias.Get(id))
         {
             if (creatorToOther.TryGetValue(alias, out a))
                 actors.AddRange(a);
             if (otherToCreator.TryGetValue(alias, out a))
                 actors.AddRange(a);
         }
         return actors.ToArray();
     }
 }
		/// <summary>
		/// Initializes a new instance of the <see cref="ExchangeInfoProvider"/>.
		/// </summary>
		/// <param name="entityRegistry">The storage of trade objects.</param>
		public ExchangeInfoProvider(IEntityRegistry entityRegistry)
		{
			if (entityRegistry == null)
				throw new ArgumentNullException(nameof(entityRegistry));

			ExchangeBoard.EnumerateExchanges().ForEach(exchange => _exchanges.Add(exchange.Name, exchange));
			ExchangeBoard.EnumerateExchangeBoards().ForEach(board => _boards.Add(board.Code, board));

			_entityRegistry = entityRegistry;

			var boardCodes = new HashSet<string>();

			var boardList = _entityRegistry.ExchangeBoards as ExchangeBoardList;
			boardCodes.AddRange(boardList != null ? boardList.GetIds() : _entityRegistry.ExchangeBoards.Select(b => b.Code));

			var boards = Boards.Where(b => !boardCodes.Contains(b.Code)).ToArray();

			if (boards.Length > 0)
			{
				boards
					.Select(b => b.Exchange)
					.Distinct()
					.ForEach(Save);

				boards
					.ForEach(Save);
			}

			_entityRegistry.Exchanges.ForEach(e => _exchanges[e.Name] = e);
			_entityRegistry.ExchangeBoards.ForEach(b => _boards[b.Code] = b);
		}
        public void AddRange_should_add_provided_values_to_target_Set()
        {
            var target = new HashSet<int>();    
            var source = new[] {1, 2, 3, 4, 5};
            target.AddRange(source);

            CollectionAssert.AreEquivalent(source, target);
        }
Example #16
0
 /// <summary>
 /// Retrieves all of the document's siblings
 /// </summary>
 /// <param name="extended">The extended <see cref="XmlDocument"/></param>
 /// <returns>An <see cref="IEnumerable{T}"/> containing all the document's sibling <see cref="XmlNode"/>s</returns>
 public static IEnumerable<XmlNode> GetAllSiblings(this XmlDocument extended)
 {
     HashSet<XmlNode> siblings;
     siblings = new HashSet<XmlNode>();
     siblings.Add(extended.FirstChild);
     siblings.AddRange(extended.FirstChild.GetAllSiblings());
     return siblings;
 }
Example #17
0
 public VirtualRepository(IPackageRepository repo)
 {
     _packages = new HashSet<IPackage>(PackageEqualityComparer.IdAndVersion);
     if (repo != null)
     {
         _packages.AddRange(repo.GetPackages());
     }
 }
Example #18
0
        /// <summary>
        /// Gets the runtime elements from the application assemblies.
        /// </summary>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// A promise of an enumeration of runtime elements.
        /// </returns>
        public async Task<IEnumerable<object>> GetRuntimeElementsAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            var assemblies = await this.appRuntime.GetAppAssembliesAsync(cancellationToken: cancellationToken).PreserveThreadContext();
            var eligibleAssemblyPairs =
                (from kv in 
                    from a in assemblies
                    select new KeyValuePair<Assembly, IList<ModelAssemblyAttribute>>(
                            a,
                            a.GetCustomAttributes<ModelAssemblyAttribute>().ToList())
                where kv.Value.Count > 0
                select kv).ToList();

            var types = new HashSet<Type>();
            foreach (var kv in eligibleAssemblyPairs)
            {
                var assembly = kv.Key;

                // first of all add all explicitely given types.
                var attrs = kv.Value;
                foreach (var attr in attrs.Where(attr => attr.ModelTypes != null && attr.ModelTypes.Length > 0))
                {
                    types.AddRange(attr.ModelTypes);
                }

                // then add the types indicated by their namespace.
                var allTypesAttribute = attrs.FirstOrDefault(a => a.ModelTypes == null && a.ModelNamespaces == null);
                if (allTypesAttribute != null)
                {
                    // if no model types or namespaces are indicated, simply add all
                    // exported types from the assembly with no further processing
                    types.AddRange(assembly.GetLoadableExportedTypes());
                }
                else
                {
                    // add only the types from the provided namespaces
                    var allTypes = assembly.GetLoadableExportedTypes().ToList();
                    var namespaces = new HashSet<string>(attrs.Where(a => a.ModelNamespaces != null && a.ModelNamespaces.Length > 0).SelectMany(a => a.ModelNamespaces));
                    var namespacePatterns = namespaces.Select(n => n + ".").ToList();
                    types.AddRange(allTypes.Where(t => namespaces.Contains(t.Namespace) || namespacePatterns.Any(p => t.Namespace.StartsWith(p))));
                }
            }

            return types;
        }
Example #19
0
        public void Run()
        {
            ITypeWeaver bulkWeaving = null;
            var compositesQueue = new Queue<ITypeWeaver>();
            AspectsAttributeWeaver aspectRepository = null;
            AspectArgsMapperWeaver aspectArgsMapperWeaver = null;
            var aspectDefinitionsTypeSet = new HashSet<Type>();

            var composites = typeFactory.Types.Select(type => new {
                                                    Type = type,
                                                    Attributes = type.GetCustomAttributesArray<CompositeAttribute>()
                                              })
                                              .Where(composite => composite.Attributes.Length > 0);

            var compositeWeavingSettings = composites.ToList(composite => {
                var compositeType = composite.Type;
                var mixinsMap = new MixinsMap(compositeType);
                var aspectMappedMembers = new AspectMemberMapper(compositeType, mixinsMap);
                var aspectsMap = new AspectsMap(aspectMappedMembers);

                var aspectDefinitionsTypes = aspectsMap.SelectMany(aspectMap => {
                    return aspectMap.Aspects.Select(aspectDefinition => {
                        return aspectDefinition.Aspect.AspectType;
                    });
                });

                aspectDefinitionsTypeSet.AddRange(aspectDefinitionsTypes);

                return new CompositeWeavingSettingsImpl {
                    Registry = registry,
                    MixinsMap = mixinsMap,
                    AspectsMap = aspectsMap,
                    CompositeType = compositeType,
                    AspectMemebrsCollection = aspectMappedMembers
                };
            });

            aspectArgsMapperWeaver = new AspectArgsMapperWeaver();
            aspectRepository = new AspectsAttributeWeaver(aspectDefinitionsTypeSet);
            compositesQueue.Enqueue(aspectArgsMapperWeaver);
            compositesQueue.Enqueue(aspectRepository);

            compositeWeavingSettings.ForEach(compositeSettings => {
                IBuilder<ITypeWeaver> builder = null;

                compositeSettings.AspectRepository = aspectRepository;
                compositeSettings.AspectArgsMapper = aspectArgsMapperWeaver;
                builder = new CompositeTypeWeaverBuilder(compositeSettings);

                compositesQueue.Enqueue(builder.Build());
            });

            bulkWeaving = new BulkWeaving(compositesQueue);
            bulkWeaving.Weave();
        }
Example #20
0
		/// <summary>
		/// Tokenize the specified string value.
		/// </summary>
		/// <returns>
		/// Returns string list which will contain only the unique word tokens in lower case which have >= 2 length from initial value.
		/// The resulting tokens also will be sorted.
		/// </returns>
		/// <param name="value">String value.</param>
		public static List<string> Tokenize(this string value)
		{
			if (value == null)
				return null;
			var tokens = stringTokenizer.Split(value);
			HashSet<string> uniqueTokens = new HashSet<string>();
			uniqueTokens.AddRange(tokens.Where(t => t.Length >= 2).Select(t => t.ToLower()));
			var sorted = uniqueTokens.ToList();
			sorted.Sort();
			return sorted;
		}
Example #21
0
File: Spin.cs Project: stewmc/vixen
		//Validate that the we are using valid colors and set appropriate defaults if not.
		private void CheckForInvalidColorData()
		{
			HashSet<Color> validColors = new HashSet<Color>();
			validColors.AddRange(TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true)));

			if (validColors.Any() &&
				(!validColors.Contains(_data.StaticColor) || !_data.ColorGradient.GetColorsInGradient().IsSubsetOf(validColors))) //Discrete colors specified
			{
				_data.ColorGradient = new ColorGradient(validColors.DefaultIfEmpty(Color.White).First());
				_data.StaticColor = validColors.First();
			}
		}
 private IEnumerable<string> GetReferencedAssemblyPaths(IList<FilePathAbsolute> projects)
 {
     var list = new HashSet<string>(projects.AsStrings());
     foreach (var binDir in projects.Select(p => p.ParentDirectoryPath))
     {
         var files = Directory.EnumerateFiles(binDir.Path, "*.*", SearchOption.AllDirectories)
                 .Where(s => s.EndsWith(".dll") || s.EndsWith(".pdb"))
                 .Where(p => !projects.Contains(p.ToFilePathAbs()));
         list.AddRange(files);
     }
     return list;
 }
Example #23
0
 /// <summary>
 /// Gets the historical data for specified symbol in format like KC, CC etc;        
 /// </summary>
 public IEnumerable<Quote> GetWeeklyData(string symbol)
 {
     var quotes = new HashSet<Quote>();
     var contractSpecification = ContractSpecification.Data.First(d => d.Symbol == symbol);
     var yearlyCodes = GetExpirationMonths(contractSpecification);
     foreach (var code in yearlyCodes)
     {
         OnDownload(code);
         quotes.AddRange(_robot.GetHistoricalData(code, Period.Weekly, BarChartProxy.FrameSize.Largest));
     }
     return new List<Quote>(quotes).OrderBy(d => d.DateTime);
 }
Example #24
0
 public ICollection<Number640> Evaluate1(IDictionary<PeerAddress, IDictionary<Number640, Number160>> rawKeys)
 {
     var result = new HashSet<Number640>();
     if (rawKeys != null)
     {
         foreach (var dictionary in rawKeys.Values)
         {
             result.AddRange(dictionary.Keys);
         }
     }
     return result;
 }
Example #25
0
File: Util.cs Project: stewmc/vixen
		public static HashSet<Color> GetDiscreteColors(object component)
		{
			var validColors = new HashSet<Color>();
			if (component is IEffect)
			{
				var effect = (IEffect)component;
				validColors.AddRange(effect.TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true)));
			}
			else if (component is Array)
			{
				foreach (var item in (Array)component)
				{
					if (item is IEffect)
					{
						var effect = (IEffect)item;
						validColors.AddRange(effect.TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true)));
					}
				}
			}

			return validColors;
		}
Example #26
0
 /// <summary>
 /// Retrieves all the siblings of the specified <see cref="XmlNode"/>
 /// </summary>
 /// <param name="extended">The extended <see cref="XmlNode"/></param>
 /// <returns>An <see cref="IEnumerable{T}"/> containing all of the <see cref="XmlNode"/> siblings</returns>
 public static IEnumerable<XmlNode> GetAllSiblings(this XmlNode extended)
 {
     HashSet<XmlNode> siblings;
     siblings = new HashSet<XmlNode>();
     if(extended.ChildNodes != null)
     {
         foreach (XmlNode node in extended.ChildNodes)
         {
             siblings.Add(node);
             siblings.AddRange(node.ChildNodes);
         }
     }
     return siblings;
 }
        public override void ExecuteCommand()
        {
            WithMasterConnection((connection, db) =>
            {
                // Get the list of backups
                var backups = db.Query<Db>(
                    "SELECT name, state FROM sys.databases WHERE name LIKE 'WarehouseBackup_%'",
                    new { state = Util.OnlineState })
                    .Select(d => new OnlineDatabaseBackup(Util.GetDatabaseServerName(ConnectionString), d.Name, d.State))
                    .OrderByDescending(b => b.Timestamp)
                    .ToList();

                // Any currently copying are safe
                var keepers = new HashSet<string>();
                keepers.AddRange(backups.Where(b => b.State == Util.CopyingState).Select(b => b.DatabaseName));

                // The last online database is safe
                keepers.AddRange(backups
                    .Where(b => b.State == Util.OnlineState && b.Timestamp != null)
                    .OrderByDescending(d => d.Timestamp.Value)
                    .Select(b => b.DatabaseName)
                    .Take(1));

                // Figure out how many we're keeping
                Log.Info("Keeping the following Backups: {0}", String.Join(", ", keepers));

                // Done! Delete the non-keepers
                foreach (var backup in backups.Where(b => !keepers.Contains(b.DatabaseName)))
                {
                    if (!WhatIf)
                    {
                        db.Execute("DROP DATABASE " + backup.DatabaseName);
                    }
                    Log.Info("Deleted {0}", backup.DatabaseName);
                }
            });
        }
Example #28
0
        public static int Answer()
        {
            int max = 28123;

            var range = Enumerable.Range(1, max).ToList();
            var abundantNumbers = range.Where(i => i.IsAbundant()).ToList();
            var abundantSums = new HashSet<int>();
            abundantSums.AddRange(from a in abundantNumbers
                                  from b in abundantNumbers
                                  select a + b);

            return range
                .Where(i => !abundantSums.Contains(i))
                .Sum();
        }
        public HgBundle BuildBundle(HgRepository hgRepository, HgRevset hgRevset)
        {
            log.Debug("bundling changelog");
            var paths = new HashSet<string>();
            var changelog = BuildChangesetBundleGroup(hgRepository, hgRevset, hc => paths.AddRange(hc.Files));

            log.Debug("bundling manifests");
            var manifest = BuildManifestBundleGroup(hgRepository, hgRevset);

            //
            // List of all files that ever were tracked
            log.Debug("bundling filelogs");
            var files = BuildBundleFiles(hgRepository, hgRevset, paths);

            var hgBundle = new HgBundle(changelog, manifest, files);
            return hgBundle;
        }
Example #30
0
		/// <summary>
		/// Tokenize the specified string values.
		/// </summary>
		/// <returns>
		/// Returns string list which will contain only the unique word tokens in lower case from each of the initial string values.
		/// The resulting tokens also will be sorted.
		/// </returns>
		/// <param name="values">Values.</param>
		public static List<string> Tokenize(this IEnumerable<string> values)
		{
			if (values == null)
				return null;
			HashSet<string> uniqueTokens = new HashSet<string>();
			foreach (var value in values)
			{
				if (value != null)
				{
					var tokens = Tokenize(value);
					uniqueTokens.AddRange(tokens);
				}
			}
			var sorted = uniqueTokens.ToList();
			sorted.Sort();
			return sorted;
		}