public DictionariesSerialization()
        {
            _serializer = Binary.Create(new Settings {
                SerializationMode = Mode.Graph
            });
            _dict          = new Dictionary <int, int>();
            _immDict       = ImmutableDictionary <int, int> .Empty;
            _immSortedDict = ImmutableSortedDictionary <int, int> .Empty;
            _sasaTrie      = Trie <int, int> .Empty;
            _hashMap       = HashMap <int, int> .Empty;

            for (int i = 0; i < 10000; ++i)
            {
                _dict.Add(i, i);
                _immDict       = _immDict.SetItem(i, i);
                _immSortedDict = _immSortedDict.SetItem(i, i);
                _sasaTrie      = _sasaTrie.Add(i, i);
                _hashMap       = _hashMap.SetItem(i, i);
            }

            _dStream       = new MemoryStream();
            _idStream      = new MemoryStream();
            _isdStream     = new MemoryStream();
            _sasaStream    = new MemoryStream();
            _hashMapStream = new MemoryStream();

            _serializer.Write(_dict, _dStream);
            _serializer.Write(_immDict, _idStream);
            _serializer.Write(_immSortedDict, _isdStream);
            _serializer.Write(_sasaTrie, _sasaStream);
            _serializer.Write(_hashMap, _hashMapStream);
        }
Exemplo n.º 2
0
 /// <summary>
 /// Delivers the given <paramref name="message"/> to a <paramref name="destination"/>. The delivery of <paramref name="message"/> is identified by
 /// the given <paramref name="deliveryId"/> which must be unique in context of the sending actor. The message is
 /// tracked as unconfirmed message until delivery is confirmed by persisting a confirmation event
 /// with `persistConfirmation`, using the same `deliveryId`.
 /// </summary>
 public void Deliver(string deliveryId, object message, ActorPath destination)
 {
     unconfirmed = unconfirmed.SetItem(deliveryId, new DeliveryAttempt(deliveryId, message, destination));
     if (!IsRecovering)
     {
         Send(message, destination);
     }
 }
 protected override ImmutableSortedDictionary <TKey, TValue> SetValues(ImmutableSortedDictionary <TKey, TValue> values, ref ArraySegment <KeyValuePair <TKey, TValue> > newValues, ISerializationContext context)
 {
     if (newValues.Count == 1)
     {
         var pair = newValues.Singleton();
         return(values.SetItem(pair.Key, pair.Value));
     }
     return(values.SetItems(newValues));
 }
Exemplo n.º 4
0
        /// <summary>
        /// TBD
        /// </summary>
        /// <param name="destination">TBD</param>
        /// <param name="deliveryMessageMapper">TBD</param>
        /// <param name="isRecovering">TBD</param>
        /// <exception cref="MaxUnconfirmedMessagesExceededException">
        /// This exception is thrown when the actor exceeds the <see cref="MaxUnconfirmedMessages"/> count.
        /// </exception>
        public void Deliver(ActorPath destination, Func <long, object> deliveryMessageMapper, bool isRecovering)
        {
            if (_unconfirmed.Count >= MaxUnconfirmedMessages)
            {
                throw new MaxUnconfirmedMessagesExceededException(
                          $"{_context.Self} has too many unconfirmed messages. Maximum allowed is {MaxUnconfirmedMessages}");
            }

            long     deliveryId = NextDeliverySequenceNr();
            DateTime now        = isRecovering ? DateTime.UtcNow - RedeliverInterval : DateTime.UtcNow;
            var      delivery   = new Delivery(destination, deliveryMessageMapper(deliveryId), now, 0);

            if (isRecovering)
            {
                _unconfirmed = _unconfirmed.SetItem(deliveryId, delivery);
            }
            else
            {
                Send(deliveryId, delivery, now);
            }
        }
Exemplo n.º 5
0
        public IPackageInfo Fetch(string packageId)
        {
            IPackageInfo package = sources.FetchPackage(packageId);

            if (package == null)
            {
                return(null);
            }

            packages = packages.SetItem(package.Id, package);
            return(package);
        }
Exemplo n.º 6
0
        public void AddOrUpdate(string configPath)
        {
            IConfig config = BuildConfig(configPath);

            if (config == null)
            {
                return;
            }

            string key = configPath.GetFullConsolidatedPath();

            configs.SetItem(key, config);
        }
Exemplo n.º 7
0
        private void SetProject(string projectPath, bool fetch)
        {
            IProject project = BuildProject(projectPath, fetch);

            if (project == null)
            {
                return;
            }

            string key = projectPath.GetFullConsolidatedPath();

            projects = projects.SetItem(key, project);
        }
Exemplo n.º 8
0
        private static ImmutableSortedDictionary <DateTime, State> AddOrUpdateStatesDictAndCleanOld(
            ImmutableSortedDictionary <DateTime, State> states, State newState,
            DateTime now)
        {
            var minEventTime = now - TimeSpan.FromMinutes(1);
            var old          = states.Keys.SkipWhile(e => e < minEventTime);

            states = states.RemoveRange(old);
            if (states.TryGetValue(now, out var oldState))
            {
                newState = new State(oldState, newState);
            }

            return(states.SetItem(now, newState));
        }
        public ParseResult <V> TryParseAt <V>(ICharParser <V> parser, int pos, int len)
        {
            long     parserId = idgen.GetId(parser);
            PosLenId posLenId = new PosLenId(pos, len, parserId);

            if (memoTable.ContainsKey(posLenId))
            {
                return((ParseResult <V>)memoTable[posLenId]);
            }
            else
            {
                ParseResult <V> r = parser.TryParse(this, pos, len);
                memoTable = memoTable.SetItem(posLenId, r);
                return(r);
            }
        }
Exemplo n.º 10
0
        public override OperationResult <TKey, TValue> Apply(ref ImmutableSortedDictionary <TKey, Sequenced <TValue> > dictionary)
        {
            if (dictionary == null)
            {
                throw new ArgumentNullException(nameof(dictionary));
            }

            if (dictionary.ContainsKey(Key))
            {
                var val = _sequenceId == -1 ? new Sequenced <TValue>(Value) : new Sequenced <TValue>(Value, _sequenceId);

                _sequenceId = val.SequenceId;

                dictionary = dictionary.SetItem(Key, val);

                return(new UpdateOperationResult <TKey, TValue>(keyNotFound: false));
            }

            return(new UpdateOperationResult <TKey, TValue>(keyNotFound: true));
        }
Exemplo n.º 11
0
    void Test()
    {
        ImmutableSortedDictionary <int, string> sortedDictionary = ImmutableSortedDictionary <int, string> .Empty;

        sortedDictionary = sortedDictionary.Add(10, "Ten");
        sortedDictionary = sortedDictionary.Add(21, "Twenty-One");
        sortedDictionary = sortedDictionary.SetItem(10, "Diez");

        // Displays "10Diez" followed by "21Twenty-One".
        foreach (KeyValuePair <int, string> item in sortedDictionary)
        {
            Trace.WriteLine(item.Key + item.Value);
        }

        string ten = sortedDictionary[10];

        // ten == "Diez"

        sortedDictionary = sortedDictionary.Remove(21);
    }
Exemplo n.º 12
0
        /// <summary>
        /// Increment the version for the node passed as argument. Returns a new VectorClock.
        /// </summary>
        /// <param name="node">Increment the vector clock value for a particular node.</param>
        /// <returns>An updated <see cref="VectorClock"/> instance.</returns>
        public VectorClock Increment(Node node)
        {
            var currentTimestamp = _versions.GetOrElse(node, Timestamp.Zero);

            return(new VectorClock(_versions.SetItem(node, currentTimestamp + 1)));
        }
Exemplo n.º 13
0
 /// <summary>
 /// Adds or replaces.
 /// </summary>
 /// <param name="k">Key</param>
 /// <param name="v">Value</param>
 /// <returns>New dictionary with the (key, value) pair added or replaced.</returns>
 public DictionaryDatum Add(Datum k, Datum v)
 {
     return(new DictionaryDatum(dict.SetItem(k, v)));
 }
Exemplo n.º 14
0
 public Tree Update(string path, TreeEntry entry) => new Tree(_items.SetItem(path, entry));
Exemplo n.º 15
0
        static void Main(string[] args)
        {
            // 不可变栈和队列
            ImmutableStack <int> stack = ImmutableStack <int> .Empty;

            stack = stack.Push(13);
            stack = stack.Push(7);
            foreach (int item in stack)
            {
                Console.WriteLine(item);
            }
            int lastItem;

            stack = stack.Pop(out lastItem);
            Console.WriteLine(lastItem);

            // 队列和栈类似
            ImmutableQueue <int> queue = ImmutableQueue <int> .Empty;

            queue = queue.Enqueue(13);
            queue = queue.Enqueue(7);
            // 在7之前显示13
            foreach (int item in queue)
            {
                Console.WriteLine(item);
            }
            int nextItem;

            queue = queue.Dequeue(out nextItem);
            // 只显示13
            Console.WriteLine(nextItem);


            //不可变列表
            ImmutableList <int> list = ImmutableList <int> .Empty;

            list = list.Insert(0, 13);
            list = list.Insert(0, 7);
            // 在13之前显示7
            foreach (int item in list)
            {
                Console.WriteLine(item);
            }
            list = list.RemoveAt(1);

            //不可变set
            //hash的
            ImmutableHashSet <int> hashSet = ImmutableHashSet <int> .Empty;

            hashSet = hashSet.Add(13);
            hashSet = hashSet.Add(7);
            // 以不可预知的顺序显示7和13
            foreach (int item in hashSet)
            {
                Console.WriteLine(item);
            }
            hashSet = hashSet.Remove(7);
            //sorted
            ImmutableSortedSet <int> sortedSet = ImmutableSortedSet <int> .Empty;

            sortedSet = sortedSet.Add(13);
            sortedSet = sortedSet.Add(7);
            // 在13之前显示7
            foreach (int item in sortedSet)
            {
                Console.WriteLine(item);
            }
            int smallestItem = sortedSet[0];

            // smallestItem == 7
            sortedSet = sortedSet.Remove(7);

            //不可变Dictionary
            //无排序
            ImmutableDictionary <int, string> dictionary =
                ImmutableDictionary <int, string> .Empty;

            dictionary = dictionary.Add(10, "Ten");
            dictionary = dictionary.Add(21, "Twenty-One");
            dictionary = dictionary.SetItem(10, "Diez");
            // 以不可预知的顺序显示10Diez和21Twenty-One
            foreach (KeyValuePair <int, string> item in dictionary)
            {
                Console.WriteLine(item.Key + item.Value);
            }
            string ten = dictionary[10];

            // ten == "Diez"
            dictionary = dictionary.Remove(21);
            //有排序
            ImmutableSortedDictionary <int, string> sortedDictionary =
                ImmutableSortedDictionary <int, string> .Empty;

            sortedDictionary = sortedDictionary.Add(10, "Ten");
            sortedDictionary = sortedDictionary.Add(21, "Twenty-One");
            sortedDictionary = sortedDictionary.SetItem(10, "Diez");
            // 在21Twenty-One之前显示10Diez
            foreach (KeyValuePair <int, string> item in sortedDictionary)
            {
                Console.WriteLine(item.Key + item.Value);
            }
            ten = sortedDictionary[10];
            // ten == "Diez"
            sortedDictionary = sortedDictionary.Remove(21);

            //线程安全的字典
            var    cd        = new ConcurrentDictionary <int, string>();
            string newvalue  = cd.AddOrUpdate(0, key => "Zero", (key, oldvalue) => "Zero");
            bool   keyExists = cd.TryGetValue(0, out string currentvalue);

            if (keyExists)
            {
                Console.WriteLine(currentvalue);
            }
            bool keyExisted = cd.TryRemove(0, out currentvalue);
            {
                Console.WriteLine(currentvalue);
            }

            //阻塞队列
            BlockingCollection <int> blockQueue = new BlockingCollection <int>();

            blockQueue.Add(7);
            blockQueue.Add(13);
            blockQueue.CompleteAdding(); //标记完成
            //消费者消费
            foreach (int item in blockQueue.GetConsumingEnumerable())
            {
                Console.WriteLine(item);
            }

            // 异步队列
            Channel <int> channelQueue = Channel.CreateUnbounded <int>();
            //生产者代码
            ChannelWriter <int> writer = channelQueue.Writer;
            var t  = writer.WriteAsync(7);
            var t2 = writer.WriteAsync(13);

            writer.Complete();
            Task.WhenAll(t.AsTask(), t2.AsTask()).Wait();
            //消费者代码
            ChannelReader <int> reader = channelQueue.Reader;

            ReaderCode(reader).Wait();
            //使用TPL完成
            var asyncQueue = new BufferBlock <int>();
            //生产者代码
            var t3 = asyncQueue.SendAsync(7);
            var t4 = asyncQueue.SendAsync(13);

            asyncQueue.Complete();
            Task.WhenAll(t3, t4).Wait();
            //消费者代码
            TPLReaderCode(asyncQueue).Wait();


            //节流队列的几种创建方式
            Channel <int>     cq = Channel.CreateBounded <int>(1);
            BufferBlock <int> b  = new BufferBlock <int>(new DataflowBlockOptions {
                BoundedCapacity = 1
            });
            BlockingCollection <int> bb = new BlockingCollection <int>(boundedCapacity: 1);

            //采样队列的几种创建方式
            cq = Channel.CreateBounded <int>(new BoundedChannelOptions(1)
            {
                FullMode = BoundedChannelFullMode.DropOldest
            });

            //使用ActionBlock来定义阻塞异步队列
            BlockAsyncQueue().Wait();
        }