static ImmutableHashSet <Point3d> CalculateDayLayout(ImmutableHashSet <Point3d> blackTiles) { var result = blackTiles.ToBuilder(); var candidates = blackTiles .SelectMany(t => AdjacentHexPoints(t).Append(t)) .Distinct(); foreach (var candidiate in candidates) { var adjacentBlackTiles = AdjacentHexPoints(candidiate).Count(p => blackTiles.Contains(p)); if (blackTiles.Contains(candidiate)) { if (adjacentBlackTiles is 0 or > 2) { result.Remove(candidiate); } } else { if (adjacentBlackTiles is 2) { result.Add(candidiate); } } } return(result.ToImmutable()); }
public override ImmutableHashSet <ValueTag> Process(BasicBlock block, ImmutableHashSet <ValueTag> input) { var output = input.ToBuilder(); // First, compute the materialization state of the basic block parameters. var preds = block.Graph.GetAnalysisResult <BasicBlockPredecessors>(); foreach (var pred in preds.GetPredecessorsOf(block).Select(block.Graph.GetBasicBlock)) { foreach (var branch in pred.Flow.Branches) { if (branch.Target != block.Tag) { continue; } foreach (var pair in branch.ZipArgumentsWithParameters(block.Graph)) { if (pair.Value.IsValue) { // A basic block parameter needs to be materialized if any of // its arguments needs to be materialized. if (output.Contains(UnfoldAliases(pair.Value.ValueOrNull, block.Graph))) { output.Add(pair.Key); } } else { // A basic block parameter needs to be materialized if any of // its arguments are special. output.Add(pair.Key); } } } } // Visit the block's instructions and determine which values need to be // materialized. foreach (var instruction in block.NamedInstructions) { UpdateMaterialization( instruction.Instruction, instruction, block.Graph, output); } // Ditto for the block's outgoing flow. foreach (var instruction in block.Flow.Instructions) { UpdateMaterialization( instruction, null, block.Graph, output); } return(output.ToImmutable()); }
protected void CreateAndAddFlocks(IEnumerable <IFlockConfiguration> configurations) { var builder = _flocks.ToBuilder(); foreach (var configuration in configurations) { var flock = CreateFlock(configuration); builder.Add(flock); OnFlockAdded(flock); } _flocks = builder.ToImmutable(); }
/// <summary> /// "Prunes the PO-Log once an operation is causally delivered in the effect. The aim is to /// keep the smallest number of PO-Log operations such that all queries return /// the same result as if the full PO-Log was present. In particular, this method discards /// operations from the PO-Log if they can be removed without impacting the output of query /// operations" /// These is called causal redundancy and it is one of the two mechanisms that conforms the semantic /// compaction used by the framework to reduce the size of pure op-based CRDTs. The other one is causal /// stabilization through <see cref="Stable(VectorTime)"/>. /// </summary> /// <param name="ops">The set of operations that conform the POLog.</param> /// <param name="newOperation">The new delivered operation.</param> /// <param name="r">A function that receives a new operation o and returns a filter that returns true if an operation o' is redundant by o.</param> /// <returns>The set of operations that conform the POLog and are not redundant by <paramref name="newOperation"/>.</returns> public ImmutableHashSet <Versioned <object> > Prune(ImmutableHashSet <Versioned <object> > ops, Versioned <object> newOperation, Redundancy r) { var builder = ops.ToBuilder(); foreach (var op in ops) { if (r(newOperation, op)) { builder.Remove(op); } } return(builder.ToImmutable()); }
static void Main(string[] args) { ImmutableHashSet <int> il = ImmutableHashSet.Create <int>(); il = il.Add(1); il = il.Add(2); il = il.Remove(2); ImmutableHashSet <int> .Builder issBuilder = il.ToBuilder(); issBuilder.Add(10); //adds to original Hashset. returns void. ImmutableHashSet <int> .Builder builder = ImmutableHashSet.CreateBuilder <int>(); builder.Add(1); il = builder.ToImmutable(); }
/// <summary> /// Adds children to the node /// </summary> /// <param name="children">child nodes to be added. Should not be null.</param> public void AddChildren(IEnumerable <IDependencyNode> children) { Requires.NotNull(children, nameof(children)); lock (_childrenLock) { var builder = _children.ToBuilder(); foreach (var child in children) { builder.Add(child); } _children = builder.ToImmutableHashSet(); } }
public ImmutableHashSet <FindSymbolResult> FindPropertyOrFieldSymbols(SemanticModel model, SyntaxList <StatementSyntax> statements, CancellationToken token) { if (model == null) { throw new ArgumentNullException(nameof(model)); } ImmutableHashSet <FindSymbolResult> symbolResults = ImmutableHashSet <FindSymbolResult> .Empty; ImmutableHashSet <FindSymbolResult> .Builder builder = symbolResults.ToBuilder(); foreach (var syntax in statements) { token.ThrowIfCancellationRequested(); EnumerateNodes(ref builder, model, syntax.DescendantNodesAndSelf(), token); } return(builder.ToImmutable()); }
public static ImmutableHashSet <T> RemoveWhere <T>(this ImmutableHashSet <T> hashSet, Predicate <T> match, out int numRemoved) { if (match == null) { throw new ArgumentNullException(nameof(match)); } var hashSetBuilder = hashSet.ToBuilder(); numRemoved = 0; foreach (var value in hashSet) { if (match(value) && hashSetBuilder.Remove(value)) { numRemoved++; } } return(hashSetBuilder.ToImmutable()); }
public ImmutableHashSet <FindSymbolResult> FindPropertyOrFieldSymbols(SemanticModel model, ExpressionSyntax expression, CancellationToken token) { if (model == null) { throw new ArgumentNullException(nameof(model)); } if (expression == null) { throw new ArgumentNullException(nameof(expression)); } ImmutableHashSet <FindSymbolResult> symbolResults = ImmutableHashSet <FindSymbolResult> .Empty; ImmutableHashSet <FindSymbolResult> .Builder builder = symbolResults.ToBuilder(); token.ThrowIfCancellationRequested(); EnumerateNodes(ref builder, model, expression.DescendantNodesAndSelf(), token); return(builder.ToImmutable()); }
public void Activate(ImmutableHashSet <ReplicationLink> replicationLinks = null) { if (replicationLinks is null) { var builder = replicationLinks.ToBuilder(); foreach (var replicationLink in replicationLinks) { if (replicationLink.Source.Acceptor != RemoteAcceptor) { builder.Remove(replicationLink); } } TargetEndpoint.System.ActorOf(Props.Create(() => new Connector(this, builder.ToImmutable()))); } else { TargetEndpoint.System.ActorOf(Props.Create(() => new Connector(this, null))); } }
public ReplicatorActor(ReplicaId myself, ReplicatorSettings settings) { this.myself = myself; this.settings = settings; replicatorRelativePath = Self.Path.ToStringWithoutAddress(); Receive <ClusterEvent.MemberUp>(up => { if (HasRole(up.Member) && up.Member.Address != cluster.SelfAddress) { // send invitation to a new member var path = up.Member.Address.ToString() + replicatorRelativePath; Context.ActorSelection(path).Tell(new Invitation(myself, Self)); } }); Receive <ClusterEvent.IMemberEvent>(_ => { /* ignore */ }); Receive <Broadcast <T> >(bcast => { var version = localVersion.Increment(myself); var versioned = new Versioned <T>(version, bcast.Message); var send = new Send <T>(myself, myself, versioned); if (log.IsInfoEnabled) { log.Info("Sending {0} to: {1}", send, string.Join(", ", members)); } foreach (var member in members) { member.Value.Forward(send); } var pendingAck = new PendingAck <T>(myself, versioned, DateTime.UtcNow, members.Keys.ToImmutableHashSet()); this.pendingAcks = pendingAcks.Add(pendingAck); this.localVersion = version; }); Receive <Send <T> >(send => { if (AlreadySeen(send.Versioned.Version)) { log.Info("Received duplicate message {0}", send); } else { var receivers = members.Remove(send.Origin); var forward = send.WithLastSeenBy(myself); if (log.IsInfoEnabled) { log.Info("Broadcasting message {0} to: {1}", forward, string.Join(", ", receivers.Values)); } foreach (var member in receivers.Values) { member.Forward(forward); } if (members.TryGetValue(send.LastSeenBy, out var sender)) { sender.Tell(new SendAck(myself, send.Versioned.Version), ActorRefs.NoSender); } var deliver = new Deliver <T>(send.Origin, send.Versioned); Self.Forward(deliver); this.pendingDelivery = pendingDelivery.Add(deliver); this.pendingAcks = pendingAcks.Add(new PendingAck <T>(myself, send.Versioned, DateTime.UtcNow, receivers.Keys.ToImmutableHashSet())); } }); Receive <SendAck>(ack => { log.Info("Received ACK from {0} (version: {1})", Sender, ack.Version); var pendingAck = this.pendingAcks.First(x => x.Versioned.Version == ack.Version); var membersLeft = pendingAck.Members.Remove(ack.ReplicaId); this.pendingAcks = pendingAcks.Remove(pendingAck); if (!membersLeft.IsEmpty) { this.pendingAcks = pendingAcks.Add(pendingAck.WithMembers(membersLeft)); } }); Receive <Deliver <T> >(deliver => { TryToCasuallyDeliver(deliver); remoteVersions = remoteVersions.SetItem(deliver.Origin, deliver.Versioned.Version); latestStableVersion = UpdateStableVersion(remoteVersions); }); Receive <Resend>(_ => { var now = DateTime.UtcNow; var builder = pendingAcks.ToBuilder(); foreach (var ack in pendingAcks) { if (now - ack.Timestamp > settings.RetryTimeout) { builder.Remove(ack); var send = new Send <T>(myself, myself, ack.Versioned); foreach (var replicaId in ack.Members) { if (members.TryGetValue(replicaId, out var member)) { member.Tell(send, ActorRefs.NoSender); } } builder.Add(ack.WithTimestamp(now)); } } pendingAcks = builder.ToImmutable(); }); Receive <Invitation>(invitation => { log.Info("Received invitation from {0} (ID: {1})", invitation.ReplicatorRef, invitation.ReplicaId); members = members.Add(invitation.ReplicaId, invitation.ReplicatorRef); Context.Watch(invitation.ReplicatorRef); }); Receive <StableReq>(sync => { var reply = sync.Versions.Where(ver => latestStableVersion >= ver).ToArray(); Sender.Tell(new StableRep(reply)); }); Receive <Subscribe <T> >(subscribe => { subscribers = subscribers.Add(subscribe.Ref); if (subscribe.Ack != null) { subscribe.Ref.Tell(subscribe.Ack); } }); Receive <Unsubscribe>(unsubscribe => { subscribers = subscribers.Remove(unsubscribe.Ref); if (unsubscribe.Ack != null) { unsubscribe.Ref.Tell(unsubscribe.Ack); } }); Receive <Terminated>(terminated => { subscribers = subscribers.Remove(terminated.ActorRef); var replicaId = members.FirstOrDefault(kv => Equals(kv.Value, terminated.ActorRef)); members = members.Remove(replicaId.Key); }); resendTask = Context.System.Scheduler .ScheduleTellOnceCancelable(settings.ResendInterval, Self, Resend.Instance, ActorRefs.NoSender); }