Example #1
0
 /** ****************************************************************************************
  * Removes a node.
  * @param  node  The node to remove.
  ******************************************************************************************/
 public void     Remove(PathMap <StoreT> node)
 {
     // we are lazy and do not remove the node. Its value just gets nulled
     node.Value = default(StoreT);
 }
Example #2
0
        /** ****************************************************************************************
         * Gets a node. If not existent and parameter \p create is \c true, the node is created.
         * @param   key        The key to the stored value.
         * @param   create     Flag if a non-existent entry should be created.
         * @param   separators A list of characters recognized as separators.
         * @return Returns the ourselves or a child node representing the key string.
         ******************************************************************************************/
        public PathMap <StoreT> Get(Substring key, bool create, AString separators)
        {
            PathMap <StoreT> node = get(key, create, separators);

            return(node != null ? node : this);
        }
Example #3
0
        // #############################################################################################
        // Protected interface
        // #############################################################################################

        /** ****************************************************************************************
         * Gets a node. If not existent and parameter \p create is \c true, the node is created.
         * @param   key        The key to the stored value.
         * @param   create     Flag if a non-existent entry should be created.
         * @param   separators A list of characters recognized as separators.
         * @return Returns the ourselves or a child node representing the key string.
         ******************************************************************************************/
        protected PathMap <StoreT> get(Substring key, bool create, AString separators)
        {
            int idx  = 0;
            int pLen = Path.Length();

            if (pLen > 0)
            {
                int    cmpLen = pLen < key.Length() ? pLen : key.Length();
                char[] kBuf   = key.Buf;
                char[] pBuf   = Path.Buffer();

                while (idx < cmpLen && kBuf[key.Start + idx] == pBuf[idx])
                {
                    idx++;
                }

                key.Consume(idx);
            }

            // all of 'our' path characters matched
            if (idx == pLen)
            {
                // identical to the searched string?
                if (key.IsEmpty())
                {
                    return(this);
                }

                // return matching child
                foreach (PathMap <StoreT> child in Childs)
                {
                    if (key.CharAtStart() == child.Path.CharAtStart())
                    {
                        PathMap <StoreT> search = child.get(key, create, separators);
                        if (search != null)
                        {
                            return(search);
                        }
                    }
                }

                // no child found
                if (create)
                {
                    PathMap <StoreT> newChild = null;
                    newChild = new PathMap <StoreT>(this);
                    newChild.Path._(key);
                    Childs.Add(newChild);
                    return(newChild);
                }
            }

            // nothing matched
            else if (idx == 0)
            {
                return(null);
            }


            // just a part of us matched
            else if (create)
            {
                // create new child receiving our old path (rest), our value and childs
                PathMap <StoreT> child1 = new PathMap <StoreT>(this);
                child1.Path._(Path, idx);

                List <PathMap <StoreT> > tempList = child1.Childs;
                foreach (PathMap <StoreT> child in Childs)
                {
                    child.Parent = child1;
                }
                child1.Childs = Childs;
                Childs        = tempList;

                child1.Value = Value;
                Childs.Clear();
                Childs.Add(child1);

                // cut my path and clear my value
                Path.SetLength_NC(idx);
                Value = default(StoreT);

                // create second child if remaining path is not empty
                if (key.IsNotEmpty())
                {
                    PathMap <StoreT> child2 = new PathMap <StoreT>(this);
                    child2.Path._(key);

                    Childs.Add(child2);
                    return(child2);
                }

                return(this);
            }

            // return us, or if this is not a real node, our parent
            if (Parent == null || idx == 0 || separators.IndexOf(Path.CharAt_NC(idx - 1)) >= 0)
            {
                return(this);
            }
            else
            {
                return(Parent);
            }
        }
Example #4
0
        // #############################################################################################
        // Public interface
        // #############################################################################################

        /** ****************************************************************************************
         * Constructor
         * @param   parent  Our parent node.
         ******************************************************************************************/
        public PathMap(PathMap <StoreT> parent = null)
        {
            this.Parent = parent;
        }
Example #5
0
            public int childNo;                     ///< The current child of the node.

            /** Constructor
             *  @param node     The node to store.
             *  @param childNo  The current child within \p node.
             */
            public NodeAndChild(PathMap <StoreT> node, int childNo)
            {
                this.node    = node;
                this.childNo = childNo;
            }