private static T GetOrAdd <T>(ref ImmutableHashSet <T> location, T value)
{
ImmutableHashSet <T> prior = Volatile.Read(ref location);
while (true)
{
if (prior.TryGetValue(value, out T existingValue))
{
// The value already exists in the set. Return it.
return(existingValue);
}
// Add a value to the set. This will succeed as we've just seen that value is not in prior.
ImmutableHashSet <T> updated = prior.Add(value);
// Attempt to update the field optimistically.
ImmutableHashSet <T> original = Interlocked.CompareExchange(ref location, updated, prior);
if (ReferenceEquals(original, prior))
{
// The update was successful; return the added icon set.
return(value);
}
// Optimistic update failed, so loop around and try again.
}
}
public T Intern(T value)
{
// Would be nice if this was on ImmutableInterlocked as
// requested in https://github.com/dotnet/corefx/issues/33653
ImmutableHashSet <T> priorCollection = Volatile.Read(ref _set);
bool successful;
do
{
if (priorCollection.TryGetValue(value, out T existingValue))
{
// The value already exists in the set. Return it.
return(existingValue);
}
ImmutableHashSet <T> updatedCollection = priorCollection.Add(value);
ImmutableHashSet <T> interlockedResult = Interlocked.CompareExchange(ref _set, updatedCollection, priorCollection);
successful = ReferenceEquals(priorCollection, interlockedResult);
priorCollection = interlockedResult; // We already have a volatile read that we can reuse for the next loop
}while (!successful);
// We won the race-condition and have updated the collection.
// Return the value that is in the collection (as of the Interlocked operation).
return(value);
}
public Wallet Put(Coin coin)
{
if (coin.Total == decimal.Zero)
{
return(this);
}
Coin oldValue;
var newCoinValue = _coins.TryGetValue(coin, out oldValue)
? oldValue.Add(coin.Count)
: coin;
var updatedWallet = _coins
.Remove(oldValue)
.Add(newCoinValue);
return(new Wallet(updatedWallet));
}
public DependencyIconSet GetOrAddIconSet(DependencyIconSet iconSet)
{
if (ThreadingTools.ApplyChangeOptimistically(ref _iconSets, iconSets => iconSets.Add(iconSet)))
{
// The cache did not already contain an equivalent icon set; use the one passed in.
return(iconSet);
}
else
{
// The cache already has an equivalent icon set; retrieve and return that one.
_iconSets.TryGetValue(iconSet, out DependencyIconSet existingIconSet);
return(existingIconSet);
}
}
public bool TryGetValue(string equalValue, out string actualValue)
{
return(_set.TryGetValue(equalValue, out actualValue));
}
/// <summary>
/// Install a NuGet package. Returns all newly installed packages.
/// </summary>
public async Task <IReadOnlyCollection <InteractivePackage> > InstallPackageAsync(
InteractivePackage package,
SourceRepository sourceRepository,
CancellationToken cancellationToken)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (!package.Identity.HasVersion)
{
throw new ArgumentException("PackageIdentity.Version must be set");
}
// TODO: File upstream issue about exception if primary source repo is offline.
// Shouldn't secondary source repos kick in? Our current work around is to
// pass the source repo from search to install, but that's not perfect.
sourceRepository = sourceRepository ?? SourceRepositories [0];
project.ResetInstallationContext();
// Just need to apply one fixup here
if (PackageIdComparer.Equals(package.Identity.Id, FixedXamarinFormsPackageIdentity.Id) &&
package.Identity.Version != FixedXamarinFormsPackageIdentity.Version)
{
Log.Warning(
TAG,
$"Replacing requested Xamarin.Forms version {package.Identity.Version} with " +
$"required version {FixedXamarinFormsPackageIdentity.Version}.");
package = package.WithVersion(
FixedXamarinFormsPackageIdentity.Version,
overwriteRange: true);
}
if (PackageIdComparer.Equals(package.Identity.Id, IntegrationPackageId))
{
Log.Warning(TAG, $"Refusing to add integration NuGet package {IntegrationPackageId}.");
return(Array.Empty <InteractivePackage> ());
}
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest, // IDEs only use Highest if upgrading
includePrelease: true,
includeUnlisted: true,
versionConstraints: VersionConstraints.None);
// Although there is a single repo associated with the package being installed,
// dependency resolution will also look into the secondary sources. In some cases,
// this can greatly slow down installation. For the primary case of searching for
// packages in nuget.org, prevent the package manager from using secondary sources
// for resolution.
//
// It is important to pass an empty enumerable, because if we pass null, the package
// manager will determine secondary sources based on the NuGet configuration.
var secondarySources =
sourceRepository == SourceRepositories [0]
? Enumerable.Empty <SourceRepository> ()
: SourceRepositories.Where(r => r != sourceRepository).ToArray();
// There does not appear to be a way to hook into or override functionality of the
// NuGetPackageManager or PackageResolver classes. In order to mess with package
// resolution, we need to either write a lot of code, proxy the sources, or intercede
// via preview installation actions.
//
// Here we do the latter, though it is not the best general-purpose approach. It works
// fine for replacing one single package that we know a LOT about. If that package's
// dependencies continually changed, we'd be better off with another approach.
var previewInstallActions = await packageManager.PreviewInstallPackageAsync(
project,
package.Identity,
resolutionContext,
projectContext,
sourceRepository,
secondarySources,
cancellationToken);
var installActions = new List <NuGetProjectAction> ();
foreach (var action in previewInstallActions)
{
// If the installed package has a dependency on Xamarin.Forms, make sure the version
// that gets installed is our preferred version. Force it to install from the primary
// source repository, because we can't assume that version is available everywhere.
//
// TODO: Consider adding a search or something to see if we can use the specified source
// instead. Could be handy if nuget.org is down or the user is offline and using
// a local repo.
if (action.PackageIdentity.Id == FixedXamarinFormsPackageIdentity.Id)
{
installActions.Add(NuGetProjectAction.CreateInstallProjectAction(
FixedXamarinFormsPackageIdentity,
SourceRepositories [0],
action.Project));
}
else
{
installActions.Add(action);
}
}
// We follow the modern behavior of .NET Core and do not actually install packages anywhere.
// Instead, we ultimately reference them out of the user's global package cache (by default,
// ~/.nuget/packages). Our NuGetProject implementation simply collects package assembly
// references (and potentially other necessary files) and populates them back into the
// InteractiveInstallationContext.
using (var sourceCacheContext = new SourceCacheContext())
await packageManager.ExecuteNuGetProjectActionsAsync(
project,
installActions,
projectContext,
sourceCacheContext,
cancellationToken);
// Identify which packages were not already noted as installed, or have been upgraded now
var newlyInstalledPackages = new List <InteractivePackage> ();
foreach (var newPackage in project.InstallationContext.InstalledPackages)
{
InteractivePackage finalNewPackage;
var foundInstalledMatch = installedPackages.TryGetValue(
newPackage,
out finalNewPackage);
if (!foundInstalledMatch ||
newPackage.Identity.Version > finalNewPackage.Identity.Version)
{
// Make sure we have a reference to a matching explicit InteractivePackage if it
// exists, so that we can persist the original SupportedVersionRange
if (!foundInstalledMatch)
{
finalNewPackage = PackageIdComparer.Equals(package, newPackage)
? package
: newPackage;
}
finalNewPackage = newPackage
.WithIsExplicit(finalNewPackage.IsExplicit)
.WithSupportedVersionRange(finalNewPackage.SupportedVersionRange);
newlyInstalledPackages.Add(finalNewPackage);
installedPackages = installedPackages
.Remove(finalNewPackage)
.Add(finalNewPackage);
UpdateInstalledPackages();
}
}
return(newlyInstalledPackages);
}
/// <inheritdoc />
public bool TryGetValue(T equalValue, out T actualValue)
{
return(_set.TryGetValue(equalValue, out actualValue));
}
private static void AnalyzeSymbols(SymbolAnalysisContext ctx)
{
PooledHashSet <ISymbol> instance1 = PooledHashSet <ISymbol> .GetInstance();
PooledHashSet <ISymbol> instance2 = PooledHashSet <ISymbol> .GetInstance();
PooledHashSet <ISymbol> instance3 = PooledHashSet <ISymbol> .GetInstance();
PooledHashSet <ISymbol> instance4 = PooledHashSet <ISymbol> .GetInstance();
PooledHashSet <ISymbol> instance5 = PooledHashSet <ISymbol> .GetInstance();
PooledHashSet <ISymbol> instance6 = PooledHashSet <ISymbol> .GetInstance();
ImmutableArray <ISymbol> members = ((IContainerSymbol)ctx.Symbol).GetMembers();
try
{
ImmutableArray <ISymbol> .Enumerator enumerator1 = members.GetEnumerator();
while (enumerator1.MoveNext())
{
ISymbol current1 = enumerator1.Current;
switch (current1.Kind)
{
case SymbolKind.GlobalVariable:
instance1.ConcurrentAdd <ISymbol>(current1);
continue;
case SymbolKind.Method:
instance2.ConcurrentAdd <ISymbol>(current1);
foreach (IVariableSymbol localVariable in ((IMethodSymbol)current1).LocalVariables)
{
instance3.ConcurrentAdd <ISymbol>((ISymbol)localVariable);
}
continue;
case SymbolKind.Field:
instance4.ConcurrentAdd <ISymbol>(current1);
continue;
case SymbolKind.Control:
Rule198GlobalLocalVariablesShouldNotHaveSameName.AnalyzeControls((IControlSymbol)current1, instance6);
continue;
case SymbolKind.Action:
Rule198GlobalLocalVariablesShouldNotHaveSameName.AnalyzeActions((IActionSymbol)current1, instance5);
continue;
case SymbolKind.Change:
IEnumerable <IControlSymbol> flattenedSymbolsOfKind1 = Rule198GlobalLocalVariablesShouldNotHaveSameName.GetFlattenedSymbolsOfKind <IControlSymbol>((IContainerSymbol)current1, SymbolKind.Control);
IEnumerable <IActionSymbol> flattenedSymbolsOfKind2 = Rule198GlobalLocalVariablesShouldNotHaveSameName.GetFlattenedSymbolsOfKind <IActionSymbol>((IContainerSymbol)current1, SymbolKind.Action);
foreach (IControlSymbol controlSymbol in flattenedSymbolsOfKind1)
{
instance6.ConcurrentAdd <ISymbol>((ISymbol)controlSymbol);
}
using (IEnumerator <IActionSymbol> enumerator2 = flattenedSymbolsOfKind2.GetEnumerator())
{
while (enumerator2.MoveNext())
{
IActionSymbol current2 = enumerator2.Current;
instance5.ConcurrentAdd <ISymbol>((ISymbol)current2);
}
continue;
}
case SymbolKind.QueryDataItem:
foreach (IQueryColumnSymbol flattenedQueryColumn in ((IQueryDataItemSymbol)current1).FlattenedQueryColumns)
{
if (flattenedQueryColumn.Kind == SymbolKind.QueryColumn)
{
instance4.ConcurrentAdd <ISymbol>((ISymbol)flattenedQueryColumn);
}
}
continue;
case SymbolKind.RequestPage:
foreach (IControlSymbol flattenedControl in ((IPageBaseTypeSymbol)current1).FlattenedControls)
{
Rule198GlobalLocalVariablesShouldNotHaveSameName.AnalyzeControls(flattenedControl, instance4);
}
foreach (IActionSymbol flattenedAction in ((IPageBaseTypeSymbol)current1).FlattenedActions)
{
instance5.ConcurrentAdd <ISymbol>((ISymbol)flattenedAction);
}
continue;
case SymbolKind.XmlPortNode:
Rule198GlobalLocalVariablesShouldNotHaveSameName.AnalyzeXmlNode((IXmlPortNodeSymbol)current1, instance4);
continue;
default:
continue;
}
}
ImmutableHashSet <ISymbol> immutableHashSet1 = instance1.ToImmutableHashSet <ISymbol>((IEqualityComparer <ISymbol>)SemanticFacts.SymbolNameEqualityComparer);
ImmutableHashSet <ISymbol> immutableHashSet2 = instance2.ToImmutableHashSet <ISymbol>((IEqualityComparer <ISymbol>)SemanticFacts.SymbolNameEqualityComparer);
ImmutableHashSet <ISymbol> immutableHashSet3 = instance3.ToImmutableHashSet <ISymbol>();
ImmutableHashSet <ISymbol> immutableHashSet4 = instance4.ToImmutableHashSet <ISymbol>((IEqualityComparer <ISymbol>)SemanticFacts.SymbolNameEqualityComparer);
ImmutableHashSet <ISymbol> immutableHashSet5 = instance5.ToImmutableHashSet <ISymbol>((IEqualityComparer <ISymbol>)SemanticFacts.SymbolNameEqualityComparer);
ImmutableHashSet <ISymbol> immutableHashSet6 = instance6.ToImmutableHashSet <ISymbol>((IEqualityComparer <ISymbol>)SemanticFacts.SymbolNameEqualityComparer);
foreach (ISymbol symbol in immutableHashSet3)
{
if (immutableHashSet1.Contains(symbol))
{
Rule198GlobalLocalVariablesShouldNotHaveSameName.ReportDiagnostic(ctx, DiagnosticDescriptors.Rule022GlobalLocalVariablesShouldNotHaveSameName, symbol);
}
if (immutableHashSet2.Contains(symbol) || immutableHashSet4.Contains(symbol) || (immutableHashSet5.Contains(symbol) || immutableHashSet6.Contains(symbol)))
{
Rule198GlobalLocalVariablesShouldNotHaveSameName.ReportDiagnostic(ctx, DiagnosticDescriptors.Rule023DoNotNameLocalVarAsFieldOrMethod, symbol);
}
}
foreach (ISymbol symbol in immutableHashSet2)
{
if (immutableHashSet4.Contains(symbol) || immutableHashSet5.Contains(symbol) || immutableHashSet6.Contains(symbol))
{
Rule198GlobalLocalVariablesShouldNotHaveSameName.ReportDiagnostic(ctx, DiagnosticDescriptors.Rule024DoNotNameMethodAsField, symbol);
}
}
foreach (ISymbol symbol in immutableHashSet1)
{
if (immutableHashSet4.Contains(symbol) || immutableHashSet2.Contains(symbol) || immutableHashSet5.Contains(symbol))
{
Rule198GlobalLocalVariablesShouldNotHaveSameName.ReportDiagnostic(ctx, DiagnosticDescriptors.Rule025DoNotNameGlobalVarAsFieldOrMethod, symbol);
}
else
{
ISymbol actualValue;
if (immutableHashSet6.Contains(symbol) && immutableHashSet6.TryGetValue(symbol, out actualValue) && actualValue.Kind != SymbolKind.Control)
{
Rule198GlobalLocalVariablesShouldNotHaveSameName.ReportDiagnostic(ctx, DiagnosticDescriptors.Rule025DoNotNameGlobalVarAsFieldOrMethod, symbol);
}
}
}
}
finally
{
instance1.Free();
instance2.Free();
instance3.Free();
instance4.Free();
instance5.Free();
instance6.Free();
}
}
public void ImmutableSetAdapter_Ctor_Succeeds()
{
const int NumberOfMethods = 17;
int[] methodsCalled = new int[NumberOfMethods];
ImmutableHashSet <int> realSet = ImmutableHashSet <int> .Empty;
System.Collections.Immutable.IImmutableSet <int> backingSet =
new MockSystemImmutableSet <int>(
addDelegate: x => { methodsCalled[0]++; return(realSet.Add(x)); },
clearDelegate: () => { methodsCalled[1]++; return(realSet.Clear()); },
containsDelegate: x => { methodsCalled[2]++; return(realSet.Contains(x)); },
countDelegate: () => { methodsCalled[3]++; return(realSet.Count); },
equalsDelegate: null,
exceptDelegate: x => { methodsCalled[4]++; return(realSet.Except(x)); },
getEnumeratorDelegate: () => { methodsCalled[5]++; return(realSet.GetEnumerator()); },
getHashCodeDelegate: null,
intersectDelegate: x => { methodsCalled[6]++; return(realSet.Intersect(x)); },
isProperSubsetOfDelegate: x => { methodsCalled[7]++; return(realSet.IsProperSubsetOf(x)); },
isProperSupersetOfDelegate: x => { methodsCalled[8]++; return(realSet.IsProperSupersetOf(x)); },
isSubsetOfDelegate: x => { methodsCalled[9]++; return(realSet.IsSubsetOf(x)); },
isSupersetOfDelegate: x => { methodsCalled[10]++; return(realSet.IsSupersetOf(x)); },
overlapsDelegate: x => { methodsCalled[11]++; return(realSet.Overlaps(x)); },
removeDelegate: x => { methodsCalled[12]++; return(realSet.Remove(x)); },
setEqualsDelegate: x => { methodsCalled[13]++; return(realSet.SetEquals(x)); },
symmetricExceptDelegate: x => { methodsCalled[14]++; return(realSet.SymmetricExcept(x)); },
toStringDelegate: null,
tryGetValueDelegate: (int x, out int y) => { methodsCalled[15]++; return(realSet.TryGetValue(x, out y)); },
unionDelegate: x => { methodsCalled[16]++; return(realSet.Union(x)); });
#pragma warning disable IDE0028 // Simplify collection initialization. Intentionally calling .Add separately for clarity
ImmutableSetAdapter <int> set = new ImmutableSetAdapter <int>(backingSet);
#pragma warning restore IDE0028 // Simplify collection initialization.
set.Add(12);
set.Clear();
set.Contains(12);
_ = set.Count;
set.Except(Array.Empty <int>());
set.GetEnumerator();
set.Intersect(Array.Empty <int>());
set.IsProperSubsetOf(Array.Empty <int>());
set.IsProperSupersetOf(Array.Empty <int>());
set.IsSubsetOf(Array.Empty <int>());
set.IsSupersetOf(Array.Empty <int>());
set.Overlaps(Array.Empty <int>());
set.Remove(12);
set.SetEquals(Array.Empty <int>());
set.SymmetricExcept(Array.Empty <int>());
set.TryGetValue(12, out _);
set.Union(Array.Empty <int>());
for (int counter = 0; counter < NumberOfMethods; counter++)
{
Assert.AreEqual(1, methodsCalled[counter]);
}
}
