Example #1
0
 private void GetFullSubscriptions(ChannelTreeNode <T> node, List <T> subscriptions)
 {
     subscriptions.AddRange(node.Items.ToList());
     foreach (var child in node.Childs)
     {
         GetFullSubscriptions(child.Value, subscriptions);
     }
 }
Example #2
0
        /// <summary>
        /// Constructor. It adds itself as a child to the parent node.
        /// </summary>
        /// <param name="parent">The parent node.</param>
        /// <param name="channelName">The channel this node represents.</param>
        public ChannelTreeNode(ChannelTreeNode <T> parent, string channelName)
        {
            Parent = parent;
            Name   = channelName;

            if (Parent != null)
            {
                Parent.Childs.TryAdd(Name, this);
            }
        }
Example #3
0
        private bool RemoveAll(ChannelTreeNode <T> node, T itemToBeRemoved)
        {
            var nodeFound = node.Items.Remove(itemToBeRemoved);

            foreach (var subnode in node.Childs)
            {
                nodeFound |= RemoveAll(subnode.Value, itemToBeRemoved);
            }
            return(nodeFound);
        }
Example #4
0
        /// <summary>
        /// Defines equality to another node if their fullname matches.
        /// </summary>
        /// <param name="obj">Another object.</param>
        /// <returns>True if the comparison object is a node and has the same fullname.</returns>
        public override bool Equals(object obj)
        {
            ChannelTreeNode <T> treeNode = null;

            if ((treeNode = obj as ChannelTreeNode <T>) == null)
            {
                return(false);
            }

            return(treeNode.FullName?.Equals(FullName) ?? false);
        }
Example #5
0
        private ChannelTreeNode <T> CreateNewHierarchy(ChannelTreeNode <T> parent, string[] channelsHierarchy, int fromIndex = 0)
        {
            var currentNode = parent;

            for (int i = fromIndex; i < channelsHierarchy.Length; i++)
            {
                currentNode = new ChannelTreeNode <T>(currentNode, channelsHierarchy[i]);
            }

            return(currentNode);
        }
Example #6
0
        /// <summary>
        /// Adds an item to a channel.
        /// </summary>
        /// <param name="channelsHierarchy">The hierarchy of channels of which the last is the channel to which the item will be added.</param>
        /// <param name="item">The item to be added.</param>
        /// <returns>True if the operation succeeded.</returns>
        public bool Add(T item, params string[] channelsHierarchy)
        {
            if (item == null)
            {
                throw new ArgumentNullException(nameof(item));
            }

            CheckChannelsNamesValidity(channelsHierarchy);

            ChannelTreeNode <T> node = null;
            var rootChannel          = channelsHierarchy[0];

            if (_root.Childs.ContainsKey(rootChannel)) // If root already exists
            {
                // Get the root
                node = _root.Childs[rootChannel];

                // Find if all channels hierarchy exists
                var firstNewChannelIndex = 1; // Index of the first new channel to be added to the hierarchy
                for (; firstNewChannelIndex < channelsHierarchy.Length; firstNewChannelIndex++)
                {
                    var currentChannelName = channelsHierarchy[firstNewChannelIndex];
                    if (!node.Childs.ContainsKey(currentChannelName))
                    {
                        break;
                    }

                    // Move the current node "down" the hierarchy
                    node = node.Childs[currentChannelName];
                }

                // If there is a new branch to be created
                if (firstNewChannelIndex < channelsHierarchy.Length)
                {
                    node = CreateNewHierarchy(node, channelsHierarchy, firstNewChannelIndex);
                }
                // node is representing the last channel in this hierarchy
            }
            else // New root hierarchy
            {
                node = new ChannelTreeNode <T>(_root, rootChannel);
                // Start creating the hierarchy from 1 because index 0 is the root channel
                node = CreateNewHierarchy(node, channelsHierarchy, fromIndex: 1);
            }

            return(node?.Items.Add(item) ?? false);
        }
Example #7
0
        private ChannelTreeNode <T> FindNode(string channel)
        {
            var channelsHierarchy = channel.Split(ChannelsSeparator);

            CheckChannelsNamesValidity(channelsHierarchy);

            ChannelTreeNode <T> node = _root;

            int i;

            for (i = 0; i < channelsHierarchy.Length; i++)
            {
                var subChannel = channelsHierarchy[i];
                if (!node.Childs.ContainsKey(subChannel))
                {
                    break;
                }

                node = node.Childs[subChannel];
            }

            return(i == channelsHierarchy.Length ? node : null);
        }
Example #8
0
 /// <summary>
 /// Clears the dictionary from all the channels.
 /// </summary>
 public void Clear() => _root = new ChannelTreeNode <T>(null, null);