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>();