private ImmutableHashSet <RemoteObserver> RemoveExcludedObservers(ImmutableHashSet <RemoteObserver> observers, PublishOptions options)
{
ImmutableHashSet <RemoteObserver> result = observers;
if (options.Exclude != null)
{
var excludedObservers =
options.Exclude.Select
(sessionId => new RemoteObserver(sessionId));
result = result.Except(excludedObservers);
}
if (options.ExcludeAuthenticationIds != null)
{
ImmutableHashSet <RemoteObserver> excludedAuthenticationIds =
GatherObservers(mAuthenticationIdToSubscription,
options.ExcludeAuthenticationIds);
result = result.Except(excludedAuthenticationIds);
}
if (options.ExcludeAuthenticationRoles != null)
{
ImmutableHashSet <RemoteObserver> excludedAuthenticationRoles =
GatherObservers(mAuthenticationRoleToSubscription,
options.ExcludeAuthenticationRoles);
result = result.Except(excludedAuthenticationRoles);
}
return(result);
}
public override void VisitView(ResolvedTreeRoot view)
{
var original = requiredResources;
base.VisitView(view);
if (original != requiredResources)
{
view.Content.AddRange(
requiredResources.Except(original).Select(r => CreateRequiredResourceControl(r, view.DothtmlNode, view.Content.First().DataContextTypeStack)));
requiredResources = original;
}
}
internal static void AddRouteBackList(IEnumerable <string> list)
{
if (list != null)
{
Allowlist = Allowlist.Except(list);
}
}
public IEnumerable <RemoteObserver> GetRelevantSubscribers(PublishOptions options)
{
ImmutableHashSet <RemoteObserver> result = mRemoteObservers;
if (options.Eligible != null)
{
var eligibleObservers =
GetRemoteObservers(options.Eligible)
.ToArray();
result = ImmutableHashSet.Create(eligibleObservers);
}
bool excludeMe = options.ExcludeMe ?? true;
PublishOptionsExtended casted = options as PublishOptionsExtended;
if (excludeMe && casted != null)
{
result = result.Remove(new RemoteObserver(casted.PublisherId));
}
if (options.Exclude != null)
{
var excludedObservers =
options.Exclude.Select
(sessionId => new RemoteObserver(sessionId));
result = result.Except(excludedObservers);
}
return(result);
}
public static CardRatings Load(MemCheckDbContext dbContext, Guid userId, ImmutableHashSet <Guid> cardIds)
{
var allCardsAverageRatings = dbContext.UserCardRatings
.AsNoTracking()
.GroupBy(userRating => userRating.CardId)
.Select(grouping => new { cardId = grouping.Key, averageRating = grouping.Average(grouping => grouping.Rating) })
.ToList(); //Filtering in memory, not on DB, is major for perf
var selectedCardsActualRatings = allCardsAverageRatings.Where(r => cardIds.Contains(r.cardId)).ToImmutableDictionary(average => average.cardId, average => average.averageRating);
var allCardsRatingCounts = dbContext.UserCardRatings
.AsNoTracking()
.GroupBy(userRating => userRating.CardId)
.Select(grouping => new { cardId = grouping.Key, count = grouping.Count() })
.ToList(); //Filtering in memory, not on DB, is major for perf
var selectedCardsRatingCounts = allCardsRatingCounts.Where(r => cardIds.Contains(r.cardId)).ToImmutableDictionary(item => item.cardId, item => item.count);
var allRatingsOfUser = dbContext.UserCardRatings
.AsNoTracking()
.Where(rating => rating.UserId == userId)
.Select(rating => new { cardId = rating.CardId, rating = rating.Rating })
.ToList(); //Filtering in memory, not on DB, is major for perf
var selectedCardsRatingsOfUser = allRatingsOfUser.Where(r => cardIds.Contains(r.cardId)).ToImmutableDictionary(item => item.cardId, item => item.rating);
var cardsWithoutEval = cardIds.Except(selectedCardsActualRatings.Keys).ToImmutableHashSet();
return(new CardRatings(selectedCardsActualRatings, selectedCardsRatingsOfUser, selectedCardsRatingCounts, cardsWithoutEval));
}
public bool Equals(ImmutableHashSet <AssemblyName> x, ImmutableHashSet <AssemblyName> y)
{
if (x.Count != y.Count)
{
return(false);
}
return(!x.Except(y).Any());
}
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]);
}
}
public LanguageSyntax(IEnumerable <string> rootTags, IEnumerable <Tag> tags, char escapeChar)
{
EscapeChar = escapeChar;
this.rootTags = rootTags.ToImmutableHashSet();
this.tags = tags.ToImmutableDictionary(c => c.Name, c => c);
Alphabet = this.tags.Select(p => p.Key).Union(this.rootTags).ToImmutableHashSet();
var notDescribedTags = Alphabet.Except(this.tags.Select(p => p.Key));
if (notDescribedTags.Count != 0)
{
throw new IncorrectSyntaxException($"Not all tags has been described: {notDescribedTags.SequenceToString()}");
}
}
private void Visit <TNodeType>(TNodeType node, List <ResolvedControl> nodeContent, Action <TNodeType> visitBase) where TNodeType : ResolvedTreeNode
{
var original = requiredResources;
visitBase(node);
if (original != requiredResources)
{
nodeContent.AddRange(
requiredResources
.Except(original)
.Select(name => CreateRequiredResourceControl(name, node.DothtmlNode, nodeContent.First().DataContextTypeStack)));
requiredResources = original;
}
}
private static void TryToReportMissingMembers(SyntaxNodeAnalysisContext context,
InitializerExpressionSyntax initializer, ImmutableHashSet <string> membersForInitialization,
Location getLocation)
{
var alreadyInitializedMembers = GetAlreadyInitializedMembers(initializer);
var missingMembers = membersForInitialization.Except(alreadyInitializedMembers);
if (missingMembers.IsEmpty == false)
{
var missingMembersList = string.Join("\r\n", missingMembers.Select(x => $"- {x}"));
var diagnostic = Diagnostic.Create(Rule, getLocation, missingMembersList);
context.ReportDiagnostic(diagnostic);
}
}
public async Task RemoveRoute(string id)
{
this.CheckClosed();
using (await this.sync.LockAsync(this.cts.Token))
{
this.CheckClosed();
ImmutableDictionary <string, Route> snapshot = this.routes;
ImmutableHashSet <Endpoint> currentEndpoints = this.Routes.SelectMany(r => r.Endpoints).ToImmutableHashSet();
this.routes.GetAndSet(snapshot.Remove(id));
ISet <string> removedEndpointIds = currentEndpoints.Except(this.Routes.SelectMany(r => r.Endpoints))
.Select(e => e.Id)
.ToImmutableHashSet();
this.evaluator.RemoveRoute(id);
await this.dispatcher.RemoveEndpoints(removedEndpointIds);
}
}
private static IEnumerable <ImmutableHashSet <T> > FindCliques(
IGraph <T> graph,
ImmutableHashSet <T> potential_clique,
ImmutableHashSet <T> remaining_nodes,
ImmutableHashSet <T> skip_nodes)
{
if (potential_clique.IsEmpty && skip_nodes.IsEmpty)
{
yield return(remaining_nodes);
}
else
{
var choices = potential_clique.Union(skip_nodes);
ImmutableHashSet <T> pivoted;
if (choices.Count > 0)
{
var pivotVertex = choices.Shuffle().First();
pivoted = potential_clique.Except(graph.Neigbours(pivotVertex));
}
else
{
pivoted = potential_clique;
}
foreach (var v in pivoted)
{
var neighborsOfV = graph.Neigbours(v);
var sub = FindCliques(
graph,
potential_clique.Intersect(neighborsOfV),
remaining_nodes.Add(v),
skip_nodes.Intersect(neighborsOfV));
foreach (var s in sub)
{
yield return(s);
}
potential_clique = potential_clique.Remove(v);
skip_nodes = skip_nodes.Add(v);
}
}
}
public void Process(ImmutableHashSet <EvalStack> set)
{
if (G == null)
{
throw new NullReferenceException("Need to init G for node " + _id);
}
var x = set.Except(_I);
if (!x.IsEmpty)
{
_I = _I.Union(x);
_O = _I.Select(s => G(s)).ToImmutableHashSet();
foreach (var n in _targets)
{
n.Process(_O);
}
}
}
public bool Equals(ImmutableHashSet <AssemblyName>?x, ImmutableHashSet <AssemblyName>?y)
{
if (x == y)
{
return(true);
}
if (x is null || y is null)
{
return(false);
}
if (x.Count != y.Count)
{
return(false);
}
return(!x.Except(y).Any());
}
private static void ReportDisposeMethods(ImmutableHashSet <IMethodSymbol> allDisposeMethods, ImmutableHashSet <IMethodSymbol> implementingDisposeMethods,
ImmutableDictionary <INamedTypeSymbol, ImmutableHashSet <IMethodSymbol> > disposeMethodsCalledFromDispose, CompilationAnalysisContext c)
{
foreach (var dispose in allDisposeMethods.Except(implementingDisposeMethods))
{
if (MethodCalledFromDispose(disposeMethodsCalledFromDispose, dispose))
{
continue;
}
foreach (var declaringSyntaxReference in dispose.DeclaringSyntaxReferences)
{
var methodDeclaration =
declaringSyntaxReference.GetSyntax() as MethodDeclarationSyntax;
if (methodDeclaration != null)
{
c.ReportDiagnosticIfNonGenerated(Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation()));
}
}
}
}
/// <summary>
/// Constructs validator with custom set of allowed and restricted characters.
/// </summary>
/// <param name="configAction">
/// Delegate to configure validator. Used for setting allowed characters and add additional restricted characters.
/// </param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="configAction" /> is null.</exception>
/// <exception cref="ArgumentException">Thrown if you set same characters for allowed and restricted.</exception>
public NoSpecialCharactersValidator(Action <INoSpecialCharactersConfigurationExpression> configAction) : this()
{
if (configAction == null)
{
throw new ArgumentNullException(nameof(configAction));
}
var builder = new NoSpecialCharactersConfigurationBuilder();
configAction(builder);
_configuration = builder.Build();
if (_configuration.AllowedChars != null && _configuration.AllowedChars.Count > 0)
{
_restrictedCharacters = _restrictedCharacters.Except(_configuration.AllowedChars);
}
if (_configuration.RestrictedChars != null && _configuration.RestrictedChars.Count > 0)
{
_restrictedCharacters = _restrictedCharacters.Union(_configuration.RestrictedChars);
}
}
/// <summary>
/// Creates a change-based checkbox list, which is a checkbox list that is based on changes to the selections rather than the absolute set of selected
/// items.
/// </summary>
/// <param name="items">The items in the list.</param>
/// <param name="selectedItemIds">The selected-item IDs.</param>
/// <param name="modificationMethod">A method that executes the change handlers of the items that were selected or deselected on this post back.</param>
/// <param name="displaySetup"></param>
/// <param name="includeSelectAndDeselectAllButtons"></param>
/// <param name="minColumnWidth">The minimum width of each column in the list. Pass null to force a single column.</param>
/// <param name="uiSelectedItemIds"></param>
/// <param name="action">The action that will occur when the user hits Enter on any of the checkboxes. Pass null to use the current default action.</param>
/// <param name="selectionChangedAction">The action that will occur when the selection is changed. Pass null for no action.</param>
/// <param name="validationPredicate"></param>
/// <param name="validationErrorNotifier"></param>
public static CheckboxList <ItemIdType> Create <ItemIdType>(
IEnumerable <ChangeBasedListItem <ItemIdType> > items, IEnumerable <ItemIdType> selectedItemIds, out Action modificationMethod,
DisplaySetup displaySetup = null, bool includeSelectAndDeselectAllButtons = false, ContentBasedLength minColumnWidth = null,
IEnumerable <ItemIdType> uiSelectedItemIds = null, SpecifiedValue <FormAction> action = null, FormAction selectionChangedAction = null,
Func <bool, bool> validationPredicate = null, Action validationErrorNotifier = null)
{
items = items.Materialize();
var selectedItemIdSet = selectedItemIds.ToImmutableHashSet();
ImmutableHashSet <ItemIdType> selectedItemIdsInPostBack = null;
modificationMethod = () => {
if (selectedItemIdsInPostBack == null)
{
return;
}
var changedItemIds = selectedItemIdsInPostBack.Except(selectedItemIdSet).Union(selectedItemIdSet.Except(selectedItemIdsInPostBack)).ToArray();
foreach (var i in items.Where(i => changedItemIds.Contains(i.Item.Id)))
{
i.ChangeHandler(selectedItemIdsInPostBack.Contains(i.Item.Id));
}
};
return(new CheckboxList <ItemIdType>(
CheckboxListSetup.Create(
from i in items select i.Item,
displaySetup: displaySetup,
includeSelectAndDeselectAllButtons: includeSelectAndDeselectAllButtons,
minColumnWidth: minColumnWidth,
action: action,
selectionChangedAction: selectionChangedAction,
validationPredicate: validationPredicate,
validationErrorNotifier: validationErrorNotifier),
uiSelectedItemIds ?? selectedItemIdSet,
validationMethod: (postBackValue, validator) => selectedItemIdsInPostBack = postBackValue.ToImmutableHashSet()));
}
private static void ReportDisposeMethods(ImmutableHashSet<IMethodSymbol> allDisposeMethods, ImmutableHashSet<IMethodSymbol> implementingDisposeMethods,
ImmutableDictionary<INamedTypeSymbol, ImmutableHashSet<IMethodSymbol>> disposeMethodsCalledFromDispose, CompilationAnalysisContext c)
{
foreach (var dispose in allDisposeMethods.Except(implementingDisposeMethods))
{
if (MethodCalledFromDispose(disposeMethodsCalledFromDispose, dispose))
{
continue;
}
foreach (var declaringSyntaxReference in dispose.DeclaringSyntaxReferences)
{
var methodDeclaration =
declaringSyntaxReference.GetSyntax() as MethodDeclarationSyntax;
if (methodDeclaration != null)
{
c.ReportDiagnostic(Diagnostic.Create(Rule, methodDeclaration.Identifier.GetLocation()));
}
}
}
}
public TestComposition RemoveExcludedPartTypes(IEnumerable <Type>?types) => WithExcludedPartTypes(ExcludedPartTypes.Except(types ?? Array.Empty <Type>()));
public TestComposition RemoveParts(IEnumerable <Type>?types) => WithParts(Parts.Except(types ?? Array.Empty <Type>()));
public TestComposition RemoveAssemblies(IEnumerable <Assembly>?assemblies) => WithAssemblies(Assemblies.Except(assemblies ?? Array.Empty <Assembly>()));
public static ImmutableHashSet <T> RemoveRange <T>(this ImmutableHashSet <T> set, IEnumerable <T> values)
{
return(set.Except(values));
}
/// <inheritdoc />
public IImmutableSet <T> Except(IEnumerable <T> other)
{
return(new SetEqualedReadOnlySet <T>(_set.Except(other)));
}
/// <summary>
/// Provide completions for the specified location.
/// </summary>
/// <param name="location">
/// The <see cref="XmlLocation"/> where completions are requested.
/// </param>
/// <param name="projectDocument">
/// The <see cref="ProjectDocument"/> that contains the <paramref name="location"/>.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> that can be used to cancel the operation.
/// </param>
/// <returns>
/// A <see cref="Task{TResult}"/> that resolves either a <see cref="CompletionList"/>s, or <c>null</c> if no completions are provided.
/// </returns>
public override async Task <CompletionList> ProvideCompletions(XmlLocation location, ProjectDocument projectDocument, CancellationToken cancellationToken = default(CancellationToken))
{
if (location == null)
{
throw new ArgumentNullException(nameof(location));
}
if (projectDocument == null)
{
throw new ArgumentNullException(nameof(projectDocument));
}
List <CompletionItem> completions = new List <CompletionItem>();
using (await projectDocument.Lock.ReaderLockAsync())
{
XSElement element;
XSAttribute replaceAttribute;
PaddingType needsPadding;
if (!location.CanCompleteAttribute(out element, out replaceAttribute, out needsPadding))
{
return(null);
}
// Must be a valid item element.
if (!element.IsValid || !element.HasParentPath(WellKnownElementPaths.ItemGroup))
{
return(null);
}
Range replaceRange = replaceAttribute?.Range ?? location.Position.ToEmptyRange();
completions.AddRange(
WellKnownItemAttributes.Except(
element.AttributeNames
)
.Select(attributeName => new CompletionItem
{
Label = attributeName,
Detail = "Attribute",
Documentation =
MSBuildSchemaHelp.ForItemMetadata(itemType: element.Name, metadataName: attributeName)
??
MSBuildSchemaHelp.ForAttribute(element.Name, attributeName),
Kind = CompletionItemKind.Field,
SortText = GetItemSortText(attributeName),
TextEdit = new TextEdit
{
NewText = $"{attributeName}=\"$1\"$0".WithPadding(needsPadding),
Range = replaceRange.ToLsp()
},
InsertTextFormat = InsertTextFormat.Snippet
})
);
}
if (completions.Count == 0)
{
return(null);
}
return(new CompletionList(completions, isIncomplete: false));
}
public ImmutableHashSet <IPhotonWirePeer> GetExceptPeers(IEnumerable <IPhotonWirePeer> peers)
{
return(currentHandlers.Except(Verify(peers)));
}
internal static bool InitPlugins()
{
string pluginsPath = Path.Combine(SharedInfo.HomeDirectory, SharedInfo.PluginsDirectory);
if (!Directory.Exists(pluginsPath))
{
ASF.ArchiLogger.LogGenericTrace(Strings.NothingFound);
return(true);
}
ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.Initializing, nameof(Plugins)));
HashSet <Assembly> assemblies = new HashSet <Assembly>();
try {
foreach (string assemblyPath in Directory.EnumerateFiles(pluginsPath, "*.dll"))
{
Assembly assembly;
try {
assembly = Assembly.LoadFrom(assemblyPath);
} catch (Exception e) {
ASF.ArchiLogger.LogGenericException(e);
continue;
}
assemblies.Add(assembly);
}
} catch (Exception e) {
ASF.ArchiLogger.LogGenericException(e);
return(false);
}
if (assemblies.Count == 0)
{
ASF.ArchiLogger.LogGenericInfo(Strings.NothingFound);
return(true);
}
ConventionBuilder conventions = new ConventionBuilder();
conventions.ForTypesDerivedFrom <IPlugin>().Export <IPlugin>();
ContainerConfiguration configuration = new ContainerConfiguration().WithAssemblies(assemblies, conventions);
try {
using (CompositionHost container = configuration.CreateContainer()) {
ActivePlugins = container.GetExports <IPlugin>().ToImmutableHashSet();
}
} catch (Exception e) {
ASF.ArchiLogger.LogGenericException(e);
return(false);
}
HashSet <IPlugin> invalidPlugins = new HashSet <IPlugin>();
foreach (IPlugin plugin in ActivePlugins)
{
try {
string pluginName = plugin.Name;
ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.PluginLoading, pluginName, plugin.Version));
plugin.OnLoaded();
ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.PluginLoaded, pluginName));
} catch (Exception e) {
ASF.ArchiLogger.LogGenericException(e);
invalidPlugins.Add(plugin);
}
}
ImmutableHashSet <IPlugin> activePlugins = ActivePlugins.Except(invalidPlugins);
if (activePlugins.Count == 0)
{
ActivePlugins = null;
return(false);
}
ActivePlugins = activePlugins;
ASF.ArchiLogger.LogGenericInfo(Strings.PluginsWarning);
return(invalidPlugins.Count == 0);
}
// FIXME it's very dangerous because replacing Id means
// ALL blocks (referenced by MineBlock(), etc.) will be changed.
internal System.Action Swap(
BlockChain <T> other,
bool render,
StateCompleterSet <T>?stateCompleters = null)
{
if (other is null)
{
throw new ArgumentNullException(nameof(other));
}
// As render/unrender processing requires every step's states from the branchpoint
// to the new/stale tip, incomplete states need to be complemented anyway...
StateCompleterSet <T> completers = stateCompleters ?? StateCompleterSet <T> .Recalculate;
if (Tip.Equals(other.Tip))
{
// If it's swapped for a chain with the same tip, it means there is no state change.
// Hence render is unnecessary.
render = false;
}
else
{
_logger.Debug(
"The blockchain was reorged from " +
"{OldChainId} (#{OldTipIndex} {OldTipHash}) " +
"to {NewChainId} (#{NewTipIndex} {NewTipHash}).",
Id,
Tip.Index,
Tip.Hash,
other.Id,
other.Tip.Index,
other.Tip.Hash);
}
System.Action renderSwap = () => { };
_rwlock.EnterUpgradeableReadLock();
try
{
// Finds the branch point.
Block <T> branchpoint = FindTopCommon(this, other);
if (branchpoint is null)
{
const string msg =
"A chain cannot be reorged into a heterogeneous chain with a " +
"different genesis.";
throw new InvalidGenesisBlockException(Genesis.Hash, other.Genesis.Hash, msg);
}
_logger.Debug(
"The branchpoint is #{BranchpointIndex} {BranchpointHash}.",
branchpoint.Index,
branchpoint
);
Block <T> oldTip = Tip, newTip = other.Tip;
ImmutableList <Block <T> > rewindPath =
GetRewindPath(this, branchpoint.Hash);
ImmutableList <Block <T> > fastForwardPath =
GetFastForwardPath(other, branchpoint.Hash);
// If there is no rewind, it is not considered as a reorg.
bool reorg = rewindPath.Count > 0;
_rwlock.EnterWriteLock();
try
{
IEnumerable <Transaction <T> >
GetTxsWithRange(BlockChain <T> chain, Block <T> start, Block <T> end)
=> Enumerable
.Range((int)start.Index + 1, (int)(end.Index - start.Index))
.SelectMany(x =>
{
// FIXME: Change the type of IBlockContent<T>.Transactions to
// IImmutableSet<Transaction<T>>, and define a distinct property
// to Block<T> for this ordering.
Block <T> block = chain[x];
return(ActionEvaluator <T> .OrderTxsForEvaluation(
block.ProtocolVersion,
block.Transactions,
block.PreEvaluationHash
));
});
// It assumes reorg is small size. If it was big, this may be heavy task.
ImmutableHashSet <Transaction <T> > unstagedTxs =
GetTxsWithRange(this, branchpoint, Tip).ToImmutableHashSet();
ImmutableHashSet <Transaction <T> > stageTxs =
GetTxsWithRange(other, branchpoint, other.Tip).ToImmutableHashSet();
ImmutableHashSet <Transaction <T> > restageTxs = unstagedTxs.Except(stageTxs);
foreach (Transaction <T> restageTx in restageTxs)
{
StagePolicy.Stage(this, restageTx);
}
Guid obsoleteId = Id;
Id = other.Id;
Store.SetCanonicalChainId(Id);
_blocks = new BlockSet <T>(Policy.GetHashAlgorithm, Store);
TipChanged?.Invoke(this, (oldTip, newTip));
Store.DeleteChainId(obsoleteId);
}
finally
{
_rwlock.ExitWriteLock();
}
renderSwap = () => RenderSwap(
render: render,
oldTip: oldTip,
newTip: newTip,
branchpoint: branchpoint,
rewindPath: rewindPath,
fastForwardPath: fastForwardPath,
stateCompleters: completers);
}
finally
{
_rwlock.ExitUpgradeableReadLock();
}
return(renderSwap);
}
