private void LoadStage() { string texoDataFolder = PathExtensions.GetAndCreateDataDirectoryPath(FileManagerConstants.STORAGE_DIRECTORY_NAME); string filePath = texoDataFolder.CombinePathWith(FileManagerConstants.STORAGE_STAGE_FILE_NAME); if (!File.Exists(filePath)) { return; } using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read)) { IStashEntry stage = serialisation.DeserializeFromStream <StashEntry>(file); if (stage == null) { return; } lobby = stage.GetLobby() ?? string.Empty; var pathsBuilder = ImmutableSortedSet.CreateBuilder(new InsensitiveFullPathComparer()); pathsBuilder.UnionWith(stage.GetPaths()); paths = pathsBuilder.ToImmutable(); } }
public static void TestDebuggerAttributes_Null() { Type proxyType = DebuggerAttributes.GetProxyType(ImmutableSortedSet.CreateBuilder <int>()); TargetInvocationException tie = Assert.Throws <TargetInvocationException>(() => Activator.CreateInstance(proxyType, (object)null)); Assert.IsType <ArgumentNullException>(tie.InnerException); }
public void CreateBuilder() { ImmutableSortedSet <string> .Builder builder = ImmutableSortedSet.CreateBuilder <string>(); Assert.NotNull(builder); builder = ImmutableSortedSet.CreateBuilder <string>(StringComparer.OrdinalIgnoreCase); Assert.Same(StringComparer.OrdinalIgnoreCase, builder.KeyComparer); }
private static ImmutableSortedSet <string> GetCategories( NUnitTypes types, ISymbol symbol ) { var categories = ImmutableSortedSet.CreateBuilder <string>(StringComparer.OrdinalIgnoreCase); VisitCategories(types, symbol, (category, _) => categories.Add(category)); return(categories.ToImmutable()); }
public void DebuggerAttributesValid() { DebuggerAttributes.ValidateDebuggerDisplayReferences(ImmutableSortedSet.CreateBuilder <string>()); DebuggerAttributes.ValidateDebuggerTypeProxyProperties(ImmutableSortedSet.CreateBuilder <int>()); ImmutableSortedSet <int> .Builder builder = ImmutableSortedSet.CreateBuilder <int>(); builder.Add(1); builder.Add(2); builder.Add(3); DebuggerAttributeInfo info = DebuggerAttributes.ValidateDebuggerTypeProxyProperties(builder); PropertyInfo itemProperty = info.Properties.Single(pr => pr.GetCustomAttribute <DebuggerBrowsableAttribute>().State == DebuggerBrowsableState.RootHidden); int[] items = itemProperty.GetValue(info.Instance) as int[]; Assert.Equal(builder, items); }
static void Main(string[] args) { ImmutableSortedSet <int> iss = ImmutableSortedSet.Create <int>(); iss = iss.Add(1); iss = iss.Add(2); iss = iss.Remove(2); ImmutableSortedSet <int> .Builder issBuilder = iss.ToBuilder(); issBuilder.Add(10); //adds to original SortedSet. returns void. ImmutableSortedSet <int> .Builder builder = ImmutableSortedSet.CreateBuilder <int>(); builder.Add(1); iss = builder.ToImmutable(); }
private IImmutableSet <TRepository> LoadRepositories() { var builder = ImmutableSortedSet.CreateBuilder(ObjectRepositoryIdComparer <TRepository> .Instance); foreach (var repositoryPath in Directory.EnumerateDirectories(Path)) { if (Repository.IsValid(repositoryPath)) { var description = new RepositoryDescription(repositoryPath); builder.Add(_repositoryLoader.LoadFrom(this, description)); } } return(builder.ToImmutable()); }
private bool CheckPrivateAttr <T>(string name, T value) { if (_config.AllAttributesPrivate || (_config.PrivateAttributeNames != null && _config.PrivateAttributeNames.Contains(name)) || (_user.PrivateAttributeNames != null && _user.PrivateAttributeNames.Contains(name))) { if (_privateAttrs is null) { _privateAttrs = ImmutableSortedSet.CreateBuilder <string>(); } _privateAttrs.Add(name); return(false); } else { return(true); } }
/// <summary> /// Creates a parser which parses and returns one of the specified characters, in a case insensitive manner. /// The parser returns the actual character parsed. /// </summary> /// <param name="chars">A sequence of characters to choose between</param> /// <returns>A parser which parses and returns one of the specified characters, in a case insensitive manner.</returns> public static Parser <char, char> CIOneOf(IEnumerable <char> chars) { if (chars == null) { throw new ArgumentNullException(nameof(chars)); } var cs = chars.Select(char.ToLowerInvariant).ToArray(); var builder = ImmutableSortedSet.CreateBuilder <Expected <char> >(); foreach (var c in cs) { builder.Add(new Expected <char>(Rope.Create(char.ToLowerInvariant(c)))); builder.Add(new Expected <char>(Rope.Create(char.ToUpperInvariant(c)))); } return(Parser <char> .Token(c => Array.IndexOf(cs, char.ToLowerInvariant(c)) != -1) .WithExpected(builder.ToImmutable())); }
/// <remarks> /// If the profile exists we return all the standard property names (as they are /// always considered defined) plus all of the defined properties supported by /// extenders. /// </remarks> public async Task <IEnumerable <string> > GetPropertyNamesAsync() { ILaunchSettings snapshot = await _launchSettingsProvider.WaitForFirstSnapshot(); ILaunchProfile?profile = snapshot.Profiles.FirstOrDefault(p => StringComparers.LaunchProfileNames.Equals(p.Name, _context.ItemName)); if (profile is null) { return(Enumerable.Empty <string>()); } ImmutableDictionary <string, object> globalSettings = snapshot.GlobalSettings; ImmutableSortedSet <string> .Builder builder = ImmutableSortedSet.CreateBuilder <string>(StringComparers.PropertyNames); builder.UnionWith(s_standardPropertyNames); foreach ((string propertyName, LaunchProfileValueProviderAndMetadata provider) in _launchProfileValueProviders) { string propertyValue = provider.Value.OnGetPropertyValue(propertyName, profile, globalSettings, _rule); if (!Strings.IsNullOrEmpty(propertyValue)) { builder.Add(propertyName); } } foreach ((string propertyName, GlobalSettingValueProviderAndMetadata provider) in _globalSettingValueProviders) { string propertyValue = provider.Value.OnGetPropertyValue(propertyName, globalSettings, _rule); if (!Strings.IsNullOrEmpty(propertyValue)) { builder.Add(propertyName); } } if (profile.OtherSettings is not null) { foreach ((string propertyName, _) in profile.OtherSettings) { builder.Add(propertyName); } } return(builder.ToImmutable()); }
async Task CanHandleBlankAndEmptyValues() { var builder = ImmutableSortedSet.CreateBuilder <string>(); builder.Add(""); var blankTaggedTextElement = new TaggedFieldValue("text", builder.ToImmutableSortedSet <string>()); builder.Clear(); builder.Add("tag"); var taggedBlankTextElement = new TaggedFieldValue("", builder.ToImmutableSortedSet <string>()); var path = Path.Combine(TestAtomFeed.Directory, "BlankAndEmptySearchResults.xml"); var message = new HttpResponseMessage(HttpStatusCode.OK); message.Content = new StreamContent(new FileStream(path, FileMode.Open, FileAccess.Read)); using (var stream = await SearchResultStream.CreateAsync(message)) { int count = 0; foreach (dynamic observedResult in stream) { Assert.Equal(observedResult._raw, string.Empty); Assert.Null(observedResult.SegmentedRaw); Assert.Equal(observedResult.blank_tagged_text_element, blankTaggedTextElement); Assert.Equal(observedResult.empty_tagged_text_element, blankTaggedTextElement); Assert.Equal(observedResult.blank_text_element, string.Empty); Assert.Equal(observedResult.blank_value_element, string.Empty); Assert.Equal(observedResult.empty_text_element, string.Empty); Assert.Equal(observedResult.tagged_blank_text_element, taggedBlankTextElement); Assert.Equal(observedResult.tagged_empty_text_element, taggedBlankTextElement); ++count; } } }
private IEnumerable <IPackageInfo> GetPackagesFromRepository(string searchTerm, string repositoryUrl) { var packages = new Dictionary <string, ImmutableSortedSet <string> .Builder>(new InsensitiveStringComparer()); var previousPackageVersions = ImmutableSortedSet.CreateBuilder <string>(new InsensitiveOpositeStringComparer()); string previousPackageId = string.Empty; PackageSearchResource resource = BuildSearchResource(repositoryUrl); var searchResult = resource.SearchAsync( searchTerm, new SearchFilter(true, null) { OrderBy = null }, 0, 10, new Logger(texoLogger), CancellationToken.None).Result; foreach (IPackageSearchMetadata metadata in searchResult) { if (!string.Equals(previousPackageId, metadata.Identity.Id, StringComparison.OrdinalIgnoreCase)) { previousPackageId = metadata.Identity.Id; if (!packages.TryGetValue(previousPackageId, out previousPackageVersions)) { previousPackageVersions = ImmutableSortedSet.CreateBuilder <string>(new InsensitiveOpositeStringComparer()); packages[previousPackageId] = previousPackageVersions; } } if (metadata.Identity.HasVersion) { previousPackageVersions.Add(metadata.Identity.Version.ToNormalizedString()); } } foreach (var packagePair in packages) { yield return(new PackageInfo(packagePair.Key, packagePair.Value.ToImmutable())); } }
public GameState(GameInformation gameInformation, IEnumerable <GameWord> words) { this.OccupationField = new BitArray(gameInformation.FieldLetters.Length, false); this.GameInformation = gameInformation; if (words != null) { var listBuilder = ImmutableSortedSet.CreateBuilder <GameWord>(); foreach (var word in words) { listBuilder.Add(word); foreach (var letter in word.GamePoints) { OccupationField[letter.Index] = true; } } this.Words = listBuilder.ToImmutable(); } else { this.Words = ImmutableSortedSet <GameWord> .Empty; } }
private IPackageInfo GetPackageFromRepository(string packageId, string repositoryUrl) { PackageMetadataResource resourse = BuildPackageResource(repositoryUrl); string resultPackageId = packageId; var versions = ImmutableSortedSet.CreateBuilder <string>(new InsensitiveOpositeStringComparer()); var metadataResult = resourse.GetMetadataAsync( packageId, true, true, null, new Logger(texoLogger), CancellationToken.None).Result; foreach (IPackageSearchMetadata metadata in metadataResult) { resultPackageId = metadata.Identity.Id; if (metadata.Identity.HasVersion) { versions.Add(metadata.Identity.Version.ToNormalizedString()); } } return(new PackageInfo(resultPackageId, versions.ToImmutable())); }
public void ToImmutableSortedSet() { ImmutableSortedSet <int> .Builder builder = ImmutableSortedSet.CreateBuilder <int>(); builder.Add(1); builder.Add(5); builder.Add(10); var set = builder.ToImmutableSortedSet(); Assert.Equal(1, builder[0]); Assert.Equal(5, builder[1]); Assert.Equal(10, builder[2]); builder.Remove(10); Assert.False(builder.Contains(10)); Assert.True(set.Contains(10)); builder.Clear(); Assert.True(builder.ToImmutableSortedSet().IsEmpty); Assert.False(set.IsEmpty); ImmutableSortedSet <int> .Builder nullBuilder = null; AssertExtensions.Throws <ArgumentNullException>("builder", () => nullBuilder.ToImmutableSortedSet()); }
private static ImmutableDictionary <IAssemblySymbol, ImmutableSortedSet <string> > GetRestrictedInternalsVisibleToMap(Compilation compilation) { var restrictedInternalsVisibleToAttribute = compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeCompilerServicesRestrictedInternalsVisibleToAttribute); if (restrictedInternalsVisibleToAttribute == null) { return(ImmutableDictionary <IAssemblySymbol, ImmutableSortedSet <string> > .Empty); } var builder = ImmutableDictionary.CreateBuilder <IAssemblySymbol, ImmutableSortedSet <string> >(); foreach (var referencedAssemblySymbol in compilation.References.Select(compilation.GetAssemblyOrModuleSymbol).OfType <IAssemblySymbol>()) { // Check IVT if (!referencedAssemblySymbol.GivesAccessTo(compilation.Assembly)) { continue; } var namespaceNameComparer = compilation.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase; var namespaceBuilder = ImmutableSortedSet.CreateBuilder(namespaceNameComparer); foreach (var assemblyAttribute in referencedAssemblySymbol.GetAttributes()) { // Look for ctor: "RestrictedInternalsVisibleToAttribute(string assemblyName, params string[] namespaces)" if (!Equals(assemblyAttribute.AttributeClass, restrictedInternalsVisibleToAttribute) || assemblyAttribute.AttributeConstructor.Parameters.Length != 2 || assemblyAttribute.AttributeConstructor.Parameters[0].Type.SpecialType != SpecialType.System_String || !(assemblyAttribute.AttributeConstructor.Parameters[1].Type is IArrayTypeSymbol arrayType) || arrayType.Rank != 1 || arrayType.ElementType.SpecialType != SpecialType.System_String || !assemblyAttribute.AttributeConstructor.Parameters[1].IsParams) { continue; } // Ensure the Restricted IVT is for the current compilation's assembly. if (assemblyAttribute.ConstructorArguments.Length != 2 || assemblyAttribute.ConstructorArguments[0].Kind != TypedConstantKind.Primitive || !(assemblyAttribute.ConstructorArguments[0].Value is string assemblyName) || !string.Equals(assemblyName, compilation.Assembly.Name, StringComparison.OrdinalIgnoreCase)) { continue; } // Ensure second constructor argument is string array. if (assemblyAttribute.ConstructorArguments[1].Kind != TypedConstantKind.Array || !(assemblyAttribute.ConstructorArguments[1].Values is var namespaceConstants)) { continue; } // Add namespaces specified in the second constructor argument. foreach (TypedConstant namespaceConstant in namespaceConstants) { if (namespaceConstant.Kind == TypedConstantKind.Primitive && namespaceConstant.Value is string namespaceName) { namespaceBuilder.Add(namespaceName); } } } if (namespaceBuilder.Count > 0) { builder.Add(referencedAssemblySymbol, namespaceBuilder.ToImmutable()); } } return(builder.ToImmutable()); }
public StressTestObject() { _entryRegistration = ImmutableSortedSet.CreateBuilder <StressTestEntry>(); _listOfStringInsertions = new StringBuilder(); }
protected Builder(BlockId id) { _id = id; _predecessors = ImmutableSortedSet.CreateBuilder <BlockId>(); _successors = ImmutableSortedSet.CreateBuilder <BlockId>(); }
public void DebuggerAttributesValid() { DebuggerAttributes.ValidateDebuggerDisplayReferences(ImmutableSortedSet.CreateBuilder <string>()); DebuggerAttributes.ValidateDebuggerTypeProxyProperties(ImmutableSortedSet.CreateBuilder <int>()); }
/// <summary> /// Asynchronously reads data into the current <see cref="SearchResult"/>. /// </summary> /// <param name="reader"> /// The <see cref="XmlReader"/> from which to read. /// </param> /// <returns> /// A <see cref="Task"/> representing the operation. /// </returns> public async Task ReadXmlAsync(XmlReader reader) { Contract.Requires <ArgumentNullException>(reader != null, "reader"); reader.MoveToElement(); reader.EnsureMarkup(XmlNodeType.Element, "result"); this.Object = new Dictionary <string, object>(); var dictionary = (IDictionary <string, object>) this.Object; this.tagsObject = new Dictionary <string, object>(); var tagsDictionary = (IDictionary <string, object>) this.tagsObject; this.SegmentedRaw = null; await reader.ReadEachDescendantAsync("field", async (r) => { ImmutableSortedSet <string> .Builder tags = null; var key = r.GetRequiredAttribute("k"); var values = new List <object>(); var fieldDepth = r.Depth; while (await r.ReadAsync().ConfigureAwait(false)) { if (r.Depth == fieldDepth) { break; } Debug.Assert(r.Depth > fieldDepth, "This loop should have exited earlier."); r.EnsureMarkup(XmlNodeType.Element, "value", "v"); if (r.IsEmptyElement) { continue; } if (r.Name == "value") { await r.ReadAsync().ConfigureAwait(false); string value = null; while (r.NodeType == XmlNodeType.Element) { r.EnsureMarkup(XmlNodeType.Element, "text", "tag"); var elementName = r.Name; string content = await r.ReadElementContentAsStringAsync().ConfigureAwait(false); switch (elementName) { case "text": value = content; break; case "tag": if (tags == null) { tags = ImmutableSortedSet.CreateBuilder <string>(); } tags.Add(content); break; } } r.EnsureMarkup(XmlNodeType.EndElement, "value"); if (tags != null && tags.Count > 0) { values.Add(new TaggedFieldValue(value ?? string.Empty, tags.ToImmutable())); tags.Clear(); } else { values.Add(value ?? string.Empty); } } else { Debug.Assert(this.SegmentedRaw == null); Debug.Assert(key == "_raw"); string value = await r.ReadOuterXmlAsync().ConfigureAwait(false); this.SegmentedRaw = XElement.Parse(value); values.Add(this.SegmentedRaw.Value); } } if (key.StartsWith("tag::")) { var valueSet = ImmutableSortedSet.ToImmutableSortedSet <string>(values.Cast <string>()); tagsDictionary.Add(key.Substring("tag::".Length), valueSet); dictionary.Add(key, valueSet); } else { switch (values.Count) { case 0: dictionary.Add(key, string.Empty); break; case 1: dictionary.Add(key, values[0]); break; default: dictionary.Add(key, new ReadOnlyCollection <object>(values)); break; } } }).ConfigureAwait(false); }
protected override ImmutableSortedSet <T> .Builder Create(int count, MessagePackSerializerOptions options) { return(ImmutableSortedSet.CreateBuilder <T>()); }
protected override ImmutableSortedSet <T> .Builder Create(int count) { return(ImmutableSortedSet.CreateBuilder <T>()); }
protected override ImmutableSortedSet <TItem> .Builder CreateProxy(int knownSize) => ImmutableSortedSet.CreateBuilder <TItem>();