Example #1
0
 private void GetHighestSequenceNumber(AsyncWriteTarget.ReadHighestSequenceNr rhsn)
 {
     LinkedList<IPersistentRepresentation> list;
     Sender.Tell(_messages.TryGetValue(rhsn.PersistenceId, out list)
         ? list.Last.Value.SequenceNr
         : 0L);
 }
Example #2
0
        private void Read(AsyncWriteTarget.ReplayMessages replay)
        {
            LinkedList<IPersistentRepresentation> list;
            if (_messages.TryGetValue(replay.PersistenceId, out list))
            {
                var filtered = list
                    .Where(x => x.SequenceNr >= replay.FromSequenceNr && x.SequenceNr <= replay.ToSequenceNr)
                    .Take(replay.Max >= int.MaxValue ? int.MaxValue : (int)replay.Max);

                foreach (var persistent in filtered)
                {
                    Sender.Tell(persistent);
                }
            }

            Sender.Tell(AsyncWriteTarget.ReplaySuccess.Instance);
        }
Example #3
0
        private void Delete(AsyncWriteTarget.DeleteMessagesTo deleteCommand)
        {
            LinkedList<IPersistentRepresentation> list;
            if (_messages.TryGetValue(deleteCommand.PersistenceId, out list))
            {
                var node = list.First;
                if (deleteCommand.IsPermanent)
                {
                    DeletePermanently(deleteCommand, node, list);
                }
                else
                {
                    MarkAsDeleted(deleteCommand, node);
                }
            }

            Sender.Tell(new object());
        }
Example #4
0
        private static void MarkAsDeleted(AsyncWriteTarget.DeleteMessagesTo deleteCommand, LinkedListNode<IPersistentRepresentation> node)
        {
            while (node != null)
            {
                if (node.Value.SequenceNr <= deleteCommand.ToSequenceNr)
                {
                    var curr = node.Value;
                    node.Value = curr.Update(sequenceNr: curr.SequenceNr,
                        persistenceId: curr.PersistenceId,
                        isDeleted: true,
                        sender: curr.Sender);
                }

                node = node.Next;
            }
        }
Example #5
0
        private void Add(AsyncWriteTarget.WriteMessages writeMessages)
        {
            foreach (var persistent in writeMessages.Messages)
            {
                var list = _messages.GetOrAdd(persistent.PersistenceId, new LinkedList<IPersistentRepresentation>());
                list.AddLast(persistent);
            }

            Sender.Tell(new object());
        }
Example #6
0
        private static void DeletePermanently(AsyncWriteTarget.DeleteMessagesTo deleteCommand, LinkedListNode<IPersistentRepresentation> node, LinkedList<IPersistentRepresentation> list)
        {
            while (node != null)
            {
                if (node.Value.SequenceNr <= deleteCommand.ToSequenceNr)
                {
                    var deleted = node;
                    node = node.Next;

                    list.Remove(deleted);
                }
                else node = node.Next;

            }
        }