Example #1
0
 public void TestAddAll()
 {
     var set = new HashSet<string>() { "a", "b", "c" };
     Assert.False(set.AddAll(new[] { "b", "c" }));
     Assert.True(set.AddAll(new[] { "c", "d" }));
     Assert.True(set.AddAll(new[] { "e", "f" }));
 }
        public virtual void TestIndexing()
        {
            DirectoryInfo tmpDir = CreateTempDir("TestNeverDelete");
            BaseDirectoryWrapper d = NewFSDirectory(tmpDir);

            // We want to "see" files removed if Lucene removed
            // them.  this is still worth running on Windows since
            // some files the IR opens and closes.
            if (d is MockDirectoryWrapper)
            {
                ((MockDirectoryWrapper)d).NoDeleteOpenFile = false;
            }
            RandomIndexWriter w = new RandomIndexWriter(Random(), d, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())).SetIndexDeletionPolicy(NoDeletionPolicy.INSTANCE));
            w.w.Config.SetMaxBufferedDocs(TestUtil.NextInt(Random(), 5, 30));

            w.Commit();
            ThreadClass[] indexThreads = new ThreadClass[Random().Next(4)];
            long stopTime = Environment.TickCount + AtLeast(1000);
            for (int x = 0; x < indexThreads.Length; x++)
            {
                indexThreads[x] = new ThreadAnonymousInnerClassHelper(w, stopTime);
                indexThreads[x].Name = "Thread " + x;
                indexThreads[x].Start();
            }

            HashSet<string> allFiles = new HashSet<string>();

            DirectoryReader r = DirectoryReader.Open(d);
            while (Environment.TickCount < stopTime)
            {
                IndexCommit ic = r.IndexCommit;
                if (VERBOSE)
                {
                    Console.WriteLine("TEST: check files: " + ic.FileNames);
                }
                allFiles.AddAll(ic.FileNames);
                // Make sure no old files were removed
                foreach (string fileName in allFiles)
                {
                    Assert.IsTrue(SlowFileExists(d, fileName), "file " + fileName + " does not exist");
                }
                DirectoryReader r2 = DirectoryReader.OpenIfChanged(r);
                if (r2 != null)
                {
                    r.Dispose();
                    r = r2;
                }
                Thread.Sleep(1);
            }
            r.Dispose();

            foreach (ThreadClass t in indexThreads)
            {
                t.Join();
            }
            w.Dispose();
            d.Dispose();

            System.IO.Directory.Delete(tmpDir.FullName, true);
        }
 public virtual void Inform(IResourceLoader loader)
 {
     IEnumerable<string> files = SplitFileNames(stopTypesFiles);
     if (files.Count() > 0)
     {
         stopTypes = new HashSet<string>();
         foreach (string file in files)
         {
             IEnumerable<string> typesLines = GetLines(loader, file.Trim());
             stopTypes.AddAll(typesLines);
         }
     }
 }
        public void TestAddAllAndForEach()
        {
            // Arrange
            var setA = new HashSet<int>();
            setA.Add(1);
            setA.Add(2);
            setA.Add(3);
            var setB = new HashSet<int>();
            setB.Add(2);
            setB.Add(4);
            setB.Add(6);

            var expectedValues = new int[] { 1, 2, 3, 4, 6 };

            // Act
            setA.AddAll(setB);

            // Assert
            Assert.AreEqual(expectedValues.Length, setA.Count());
            expectedValues.ForEach(expected => Assert.IsTrue(setA.Contains(expected)));
        }
Example #5
0
        private static async Task<SearchResult> AddLocationsReferenceSymbolsAsync(
            ISymbol symbol,
            Solution solution,
            CancellationToken cancellationToken)
        {
            var locations = new HashSet<RenameLocation>();
            var referenceSymbols = await SymbolFinder.FindRenamableReferencesAsync(symbol, solution, cancellationToken).ConfigureAwait(false);

            foreach (var referencedSymbol in referenceSymbols)
            {
                locations.AddAll(
                    await ReferenceProcessing.GetRenamableDefinitionLocationsAsync(referencedSymbol.Definition, symbol, solution, cancellationToken).ConfigureAwait(false));

                locations.AddAll(
                    await referencedSymbol.Locations.SelectManyAsync<ReferenceLocation, RenameLocation>(
                        (l, c) => ReferenceProcessing.GetRenamableReferenceLocationsAsync(referencedSymbol.Definition, symbol, l, solution, c),
                        cancellationToken).ConfigureAwait(false));
            }

            var implicitLocations = new List<ReferenceLocation>(referenceSymbols.SelectMany(refSym => refSym.Locations).Where(loc => loc.IsImplicit));
            var referencedSymbols = new List<ISymbol>(referenceSymbols.Select(r => r.Definition).Where(r => !r.Equals(symbol)));

            return new SearchResult(locations, implicitLocations, referencedSymbols);
        }
        /// <summary>
        /// Increments the versions of sdmx objects
        /// </summary>
        /// <param name="sdmxObjects">
        /// The sdmx objects.
        /// </param>
        public void IncrementVersions(ISdmxObjects sdmxObjects)
        {
            _log.Info("Update Versions of Structures if existing structures found");
            //Store a map of old versions vs the new version
            IDictionary<IStructureReference, IStructureReference> oldVsNew =
                new Dictionary<IStructureReference, IStructureReference>();
            IDictionary<IMaintainableObject, IMaintainableObject> oldMaintVsNew =
                new Dictionary<IMaintainableObject, IMaintainableObject>();
            ISet<IMaintainableObject> updatedMaintainables = new HashSet<IMaintainableObject>();
            ISet<IMaintainableObject> oldMaintainables = new HashSet<IMaintainableObject>();

            foreach (IMaintainableObject currentMaint in sdmxObjects.GetAllMaintainables())
            {
                _log.Debug("Auto Version - check latest version for maintainable: " + currentMaint);

                IMaintainableObject persistedMaintainable = this._structureVersionRetrievalManager.GetLatest(currentMaint);
                if (persistedMaintainable == null)
                {
                    persistedMaintainable = this._beanRetrievalManager.GetMaintainableObject(currentMaint.AsReference);
                }
                if (persistedMaintainable != null)
                {
                    if (VersionableUtil.IsHigherVersion(persistedMaintainable.Version, currentMaint.Version))
                    {
                        //Modify version of maintainable to be the same as persisted maintainable
                        IMaintainableMutableObject mutableInstance = currentMaint.MutableInstance;
                        mutableInstance.Version = persistedMaintainable.Version;

                        //Remove the Maintainable from the submission - as we've changed the versions
                        sdmxObjects.RemoveMaintainable(currentMaint);

                        //currentMaint = mutableInstance.ImmutableInstance;
                    }
                    if (persistedMaintainable.Version.Equals(currentMaint.Version))
                    {
                        _log.Debug("Latest version is '" + persistedMaintainable.Version + "' perform update checks");
                        if (!currentMaint.DeepEquals(persistedMaintainable, true))
                        {
                            ISet<IIdentifiableObject> allIdentifiables1 = currentMaint.IdentifiableComposites;
                            ISet<IIdentifiableObject> allIdentifiables2 = persistedMaintainable.IdentifiableComposites;

                            bool containsAll = allIdentifiables1.ContainsAll(allIdentifiables2)
                                               && allIdentifiables2.ContainsAll(allIdentifiables1);
                            if (_log.IsInfoEnabled)
                            {
                                string increment = containsAll ? "Minor" : "Major";
                                _log.Info("Perform " + increment + " Version Increment for structure:" + currentMaint.Urn);
                            }

                            //Increment the version number
                            IMaintainableObject newVersion = this.IncrmentVersion(
                                currentMaint, persistedMaintainable.Version, !containsAll);

                            //Remove the Maintainable from the submission
                            sdmxObjects.RemoveMaintainable(currentMaint);

                            //Store the newly updated maintainable in a container for further processing
                            updatedMaintainables.Add(newVersion);
                            oldMaintainables.Add(currentMaint);
                            //Store the old version number mappings to the new version number
                            oldMaintVsNew.Add(currentMaint, newVersion);
                            oldVsNew.Add(currentMaint.AsReference, newVersion.AsReference);

                            string oldVersionNumber = currentMaint.Version;
                            AddOldVsNewReferences(oldVersionNumber, newVersion, oldVsNew);
                        }
                    }
                }
            }

            //Create a set of parent sdmxObjects to not update (regardless of version)
            ISet<IMaintainableObject> filterSet = new HashSet<IMaintainableObject>(updatedMaintainables);
            filterSet.AddAll(sdmxObjects.GetAllMaintainables());

            //Get all the referencing structures to reversion them
            IEnumerable<IMaintainableObject> referencingStructures = this.RecurseUpTree(oldMaintainables, new HashSet<IMaintainableObject>(), filterSet);

            foreach (IMaintainableObject currentReferencingStructure in referencingStructures)
            {
                _log.Info("Perform Minor Version Increment on referencing structure:" + currentReferencingStructure);
                String newVersionNumber;
                if (oldMaintVsNew.ContainsKey(currentReferencingStructure))
                {
                    //The old maintainable is also in the submission and has had it's version number incremented, use this version
                    var tmp = oldMaintVsNew[currentReferencingStructure];
                    //currentReferencingStructure = oldMaintVsNew[currentReferencingStructure];
                    updatedMaintainables.Remove(tmp);
                    newVersionNumber = currentReferencingStructure.Version;
                }
                else
                {
                    newVersionNumber = VersionableUtil.IncrementVersion(currentReferencingStructure.Version, false);
                }
                IMaintainableObject updatedMaintainable =
                    this._crossReferenceReversionEngine.UdpateReferences(
                        currentReferencingStructure, oldVsNew, newVersionNumber);
                AddOldVsNewReferences(currentReferencingStructure.Version, updatedMaintainable, oldVsNew);

                updatedMaintainables.Add(updatedMaintainable);
            }

            foreach (IMaintainableObject currentReferencingStructure in updatedMaintainables)
            {
                IMaintainableObject updatedMaintainable =
                    this._crossReferenceReversionEngine.UdpateReferences(
                        currentReferencingStructure, oldVsNew, currentReferencingStructure.Version);
                sdmxObjects.AddIdentifiable(updatedMaintainable);
            }

            //Update the references of any structures that existed in the submission
            foreach (IMaintainableObject currentReferencingStructure in sdmxObjects.GetAllMaintainables())
            {
                IMaintainableObject updatedMaintainable =
                    this._crossReferenceReversionEngine.UdpateReferences(
                        currentReferencingStructure, oldVsNew, currentReferencingStructure.Version);
                sdmxObjects.AddIdentifiable(updatedMaintainable);
            }
        }
 public static ISet Union(ISet a, ISet b)
 {
   IMutableSet union = new HashSet(a);
   union.AddAll(b);
   return union;
 }
Example #8
0
        private static async Task<IEnumerable<INamedTypeSymbol>> FindSourceTypesInProjectAsync(
            HashSet<INamedTypeSymbol> sourceAndMetadataTypes,
            Project project,
            Func<HashSet<INamedTypeSymbol>, INamedTypeSymbol, bool> sourceTypeImmediatelyMatches,
            Func<INamedTypeSymbol, bool> shouldContinueSearching,
            bool transitive,
            CancellationToken cancellationToken)
        {
            // We're going to be sweeping over this project over and over until we reach a 
            // fixed point.  In order to limit GC and excess work, we cache all the sematic
            // models and DeclaredSymbolInfo for hte documents we look at.
            // Because we're only processing a project at a time, this is not an issue.
            var cachedModels = new ConcurrentSet<SemanticModel>();
            var cachedInfos = new ConcurrentSet<IDeclarationInfo>();

            var finalResult = new HashSet<INamedTypeSymbol>(SymbolEquivalenceComparer.Instance);

            var typesToSearchFor = new HashSet<INamedTypeSymbol>(SymbolEquivalenceComparer.Instance);
            typesToSearchFor.AddAll(sourceAndMetadataTypes);

            var inheritanceQuery = new InheritanceQuery(sourceAndMetadataTypes);

            // As long as there are new types to search for, keep looping.
            while (typesToSearchFor.Count > 0)
            {
                // Compute the set of names to look for in the base/interface lists.
                inheritanceQuery.TypeNames.AddRange(typesToSearchFor.Select(c => c.Name));

                // Search all the documents of this project in parallel.
                var tasks = project.Documents.Select(d => FindImmediatelyInheritingTypesInDocumentAsync(
                    d, typesToSearchFor, inheritanceQuery,
                    cachedModels, cachedInfos, 
                    sourceTypeImmediatelyMatches, cancellationToken)).ToArray();

                await Task.WhenAll(tasks).ConfigureAwait(false);

                // Clear out the information about the types we're looking for.  We'll
                // fill these in if we discover any more types that we need to keep searching
                // for.
                typesToSearchFor.Clear();
                inheritanceQuery.TypeNames.Clear();

                foreach (var task in tasks)
                {
                    if (task.Result != null)
                    {
                        foreach (var derivedType in task.Result)
                        {
                            if (finalResult.Add(derivedType))
                            {
                                if (transitive && shouldContinueSearching(derivedType))
                                {
                                    typesToSearchFor.Add(derivedType);
                                }
                            }
                        }
                    }
                }
            }

            return finalResult;
        }
Example #9
0
        public void Init()
        {
            var parent = Path.GetDirectoryName (DiskPath);
            var siblings = new SortedDictionary<string, Page> ();

            foreach (var i in Tacker.Pages) {
                if (i.DiskPath.Equals (parent)) {
                    Parent = i;
                }
                if (parent.Equals (Path.GetDirectoryName (i.DiskPath)) &&
                    i != this && !i.IsFloating) {
                    siblings.Add (Path.GetFileName (i.DiskPath), i);
                }
            }

            Siblings = new List<Page> (siblings.Values);

            var metadata = new Dictionary<string, object> ();
            var assets = new HashSet<string> ();

            foreach (var i in Files.GetAllFiles (DiskPath)) {
                var md = Tacker.ProcessMetadata (i);
                if (md != null) {
                    Template = Template ?? Path.GetFileNameWithoutExtension (i);
                    metadata.AddAll (md);
                    continue;
                }
                var markup = Tacker.ProcessMarkup (i);
                if (markup != null) {
                    metadata.Add (Path.GetFileNameWithoutExtension (i), markup);
                    continue;
                }

                assets.Add (i);
            }

            var pagePaths = new HashSet<string> ();
            foreach (var page in Tacker.Pages) {
                pagePaths.Add (page.DiskPath);
            }

            foreach (var subdir in Files.EnumerateAllSubdirs (DiskPath)) {
                if (!pagePaths.Contains (subdir)) {
                    assets.AddAll (Files.GetAllFiles (subdir));
                }
            }

            Assets = new HashSet<string> (assets.Select (x => x.Replace (DiskPath, "")));
            Variables = metadata;
            inited = true;
        }
Example #10
0
        /// <summary>
        /// Given a path to an assembly and a set of paths to possible dependencies,
        /// identifies which of the assembly's references are missing. May throw.
        /// </summary>
        /// <exception cref="IOException">If the files does not exist or cannot be accessed.</exception>
        /// <exception cref="BadImageFormatException">If one of the files is not an assembly or is somehow corrupted.</exception>
        public static ImmutableArray<AssemblyIdentity> IdentifyMissingDependencies(string assemblyPath, IEnumerable<string> dependencyFilePaths)
        {
            Debug.Assert(assemblyPath != null);
            Debug.Assert(PathUtilities.IsAbsolute(assemblyPath));
            Debug.Assert(dependencyFilePaths != null);

            HashSet<AssemblyIdentity> assemblyDefinitions = new HashSet<AssemblyIdentity>();
            foreach (var potentialDependency in dependencyFilePaths)
            {
                using (var reader = new PEReader(FileUtilities.OpenRead(potentialDependency)))
                {
                    var metadataReader = reader.GetMetadataReader();
                    var assemblyDefinition = metadataReader.ReadAssemblyIdentityOrThrow();

                    assemblyDefinitions.Add(assemblyDefinition);
                }
            }

            HashSet<AssemblyIdentity> assemblyReferences = new HashSet<AssemblyIdentity>();
            using (var reader = new PEReader(FileUtilities.OpenRead(assemblyPath)))
            {
                var metadataReader = reader.GetMetadataReader();

                var references = metadataReader.GetReferencedAssembliesOrThrow();

                assemblyReferences.AddAll(references);
            }

            assemblyReferences.ExceptWith(assemblyDefinitions);

            return ImmutableArray.CreateRange(assemblyReferences);
        }
 public virtual void Inform(ResourceLoader loader)
 {
     IList<string> files = splitFileNames(stopTypesFiles);
     if (files.Count > 0)
     {
         stopTypes = new HashSet<string>();
         foreach (string file in files)
         {
             IList<string> typesLines = getLines(loader, file.Trim());
             stopTypes.AddAll(typesLines);
         }
     }
 }
        /// <summary>
        /// Get subset workspace from <paramref name="query"/>
        /// </summary>
        /// <param name="query">
        /// The query.
        /// </param>
        /// <returns>
        /// The <see cref="IStructureWorkspace"/>.
        /// </returns>
        public virtual IStructureWorkspace GetSubsetWorkspace(params IStructureReference[] query)
        {
            ISet<IMaintainableObject> maintainablesSubset = new HashSet<IMaintainableObject>();
            IDictionaryOfSets<IIdentifiableObject, IIdentifiableObject> crossReferencedSubset = new DictionaryOfSets<IIdentifiableObject, IIdentifiableObject>();

            for (int i = 0; i < query.Length; i++)
            {
                IStructureReference currentQuery = query[i];
                ISet<IMaintainableObject> maintainableForStructure =
                    this._sdmxObjects.GetMaintainables(currentQuery.MaintainableStructureEnumType.EnumType);
                ISet<IMaintainableObject> maintainableMatches =
                    MaintainableUtil<IMaintainableObject>.FindMatches(maintainableForStructure, currentQuery);
                maintainablesSubset.AddAll(maintainableMatches);

                /* foreach */
                foreach (IMaintainableObject currentMatch in maintainableMatches)
                {
                    ISet<IIdentifiableObject> identifiables = (this._crossReferencedObjects == null)
                                                                  ? (new HashSet<IIdentifiableObject>())
                                                                  : this._crossReferencedObjects[currentMatch];
                    if (identifiables != null)
                    {
                        crossReferencedSubset.Add(currentMatch, identifiables);
                    }
                }
            }

            ISdmxObjects beansSubset = new SdmxObjectsImpl(this._sdmxObjects.Header, maintainablesSubset);
            return new StructureWorkspace(beansSubset, crossReferencedSubset);
        }
        /// <summary>
        ///   The resolve references internal.
        /// </summary>
        /// <param name="sdmxObjects"> The sdmxObjects. </param>
        /// <param name="retrievalManager"> The retrieval manager. </param>
        /// <param name="populateMissingMap"> The populate missing map. </param>
        /// <returns> The <see cref="IIdentifiableObject" /> dictionary. </returns>
        /// <exception cref="CrossReferenceException">Reference error</exception>
        private IDictionaryOfSets<IIdentifiableObject, IIdentifiableObject> ResolveReferencesInternal(
            ISdmxObjects sdmxObjects,
            IIdentifiableRetrievalManager retrievalManager,
            IDictionary<IIdentifiableObject, ISet<ICrossReference>> populateMissingMap)
        {
            _log.Info("Resolve References, bean retrieval manager: " + retrievalManager);

            /* foreach */
            foreach (IAgency currentAgency in sdmxObjects.Agencies)
            {
                this._agencies.Add(currentAgency.FullId, currentAgency);
            }

            // Add all the top level sdmxObjects to the maintainables list
            this.AddObjectsToMap(sdmxObjects);

            // LOOP THROUGH ALL THE BEANS AND RESOLVE ALL THE REFERENCES
            if (this._resolveAgencies)
            {
                /* foreach */
                foreach (IMaintainableObject currentBean in sdmxObjects.GetAllMaintainables())
                {
                    try
                    {
                        this.ResolveAgency(currentBean, retrievalManager);
                    }
                    catch (CrossReferenceException e)
                    {
                        throw new SdmxReferenceException(e,
                            AgencyRef(currentBean.AgencyId));
                    }
                }
            }

            ISet<IMaintainableObject> loopSet = new HashSet<IMaintainableObject>();
            loopSet.AddAll(sdmxObjects.GetAllMaintainables());
            ISdmxObjectRetrievalManager retMan = new InMemoryRetrievalManager(sdmxObjects);

            /* foreach */
            foreach (IMaintainableObject currentMaintainable in loopSet)
            {
                this._log.Debug("Resolving References For : " + currentMaintainable.Urn);
                ISet<ICrossReference> crossReferences0;
                if (_maintainableCrossReferenceRetrieverEngine != null)
                {
                    crossReferences0 = _maintainableCrossReferenceRetrieverEngine.GetCrossReferences(retMan, currentMaintainable);
                }
                else
                {
                    crossReferences0 = currentMaintainable.CrossReferences;
                }
                this._log.Debug("Number of References : " + crossReferences0.Count);
                int i = 0;

                /* foreach */
                foreach (ICrossReference crossReference in crossReferences0)
                {
                    i++;
                    if (this._log.IsDebugEnabled)
                    {
                        this._log.Debug(
                            "Resolving Reference " + i + ": " + crossReference + " - referenced from -"
                            + crossReference.ReferencedFrom.StructureType);
                    }

                    try
                    {
                        this.StoreRef(
                            crossReference.ReferencedFrom, this.ResolveCrossReference(crossReference, retrievalManager));
                    }
                    catch (CrossReferenceException e)
                    {
                        if (populateMissingMap == null)
                        {
                            throw;
                        }
                        
                        HandleMissingReference(e, populateMissingMap);
                        //throw new ReferenceException(e, "Reference from structure '" + currentMaintainable.Urn + "' can not be resolved");
                    }
                }
            }

            return this._crossReferences;
        }
        /// <summary>
        ///   Returns a set of IdentifiableBeans that the IMaintainableObject cross references
        /// </summary>
        /// <param name="bean"> The bean. </param>
        /// <param name="resolveAgencies"> - if true will also resolve the agencies </param>
        /// <param name="numberLevelsDeep"> references, an argument of 0 (zero) implies there is no limit, and the resolver engine will continue re-cursing until it has found every directly and indirectly referenced artifact. Note that there is no risk of infinite recursion in calling this. </param>
        /// <param name="retrievalManager"> - Used to resolve the structure references. Can be null, if supplied this is used to resolve any references that do not exist in the supplied sdmxObjects </param>
        /// <exception cref="CrossReferenceException">- if any of the references could not be resolved</exception>
        /// <returns> a set of IdentifiableBeans that the IMaintainableObject cross references </returns>
        public virtual ISet<IIdentifiableObject> ResolveReferences(
            IMaintainableObject bean,
            bool resolveAgencies,
            int numberLevelsDeep,
            IIdentifiableRetrievalManager retrievalManager)
        {
            this.ResetMaps();
            ISdmxObjects beans = new SdmxObjectsImpl();
            beans.AddIdentifiable(bean);
            IDictionary<IIdentifiableObject, ISet<IIdentifiableObject>> references = this.ResolveReferences(
                beans, resolveAgencies, numberLevelsDeep, retrievalManager);

            ISet<IIdentifiableObject> returnSet = new HashSet<IIdentifiableObject>();

            /* foreach */
            foreach (KeyValuePair<IIdentifiableObject, ISet<IIdentifiableObject>> key in references)
            {
                returnSet.AddAll(key.Value);
            }

            return returnSet;
        }