Exemple #1
0
        /// <summary>
        /// Create an instance of the enumerator for a given node.
        /// </summary>
        /// <param name="fsa">The automaton to iterate over.</param>
        /// <param name="node">The starting node's identifier (can be the <see cref="FSA.GetRootNode()"/>.</param>
        public ByteSequenceEnumerator(FSA fsa, int node)
        {
            this.bufferWrapper = ByteBuffer.Wrap(buffer);
            this.fsa           = fsa;

            if (fsa.GetFirstArc(node) != 0)
            {
                RestartFrom(node);
            }
        }
Exemple #2
0
        // .NET doesn't support Remove()

        /// <summary>
        /// Descends to a given node, adds its arcs to the stack to be traversed.
        /// </summary>
        private void PushNode(int node)
        {
            // Expand buffers if needed.
            if (position == arcs.Length)
            {
                Array.Resize(ref arcs, arcs.Length + ExpectedMaxStates);
            }

            arcs[position++] = fsa.GetFirstArc(node);
        }
Exemple #3
0
        /// <summary>
        /// Calculate perfect hash for a given input sequence of bytes. The perfect hash requires
        /// that <see cref="FSA"/> is built with <see cref="FSAFlags.Numbers"/> and corresponds to the sequential
        /// order of input sequences used at automaton construction time.
        /// </summary>
        /// <param name="sequence">The byte sequence to calculate perfect hash for.</param>
        /// <param name="start">Start index in the sequence array.</param>
        /// <param name="length">Length of the byte sequence, must be at least 1.</param>
        /// <param name="node">The node to start traversal from, typically the root node (<see cref="FSA.GetRootNode()"/>).</param>
        /// <returns>
        /// Returns a unique integer assigned to the input sequence in the automaton (reflecting
        /// the number of that sequence in the input used to build the automaton). Returns a negative
        /// integer if the input sequence was not part of the input from which the automaton was created.
        /// The type of mismatch is a constant defined in <see cref="MatchResult"/>.
        /// </returns>
        /// <seealso cref="PerfectHash(byte[])"/>
        public int PerfectHash(byte[] sequence, int start, int length, int node)
        {
            Debug.Assert((fsa.Flags & FSAFlags.Numbers) != 0, $"FSA not built with {FSAFlags.Numbers} option.");
            Debug.Assert(length > 0, "Must be a non-empty sequence.");

            int hash = 0;
            int end  = start + length - 1;

            int  seqIndex = start;
            byte label    = sequence[seqIndex];

            // Seek through the current node's labels, looking for 'label', update hash.
            for (int arc = fsa.GetFirstArc(node); arc != 0;)
            {
                if (fsa.GetArcLabel(arc) == label)
                {
                    if (fsa.IsArcFinal(arc))
                    {
                        if (seqIndex == end)
                        {
                            return(hash);
                        }

                        hash++;
                    }

                    if (fsa.IsArcTerminal(arc))
                    {
                        /* The automaton contains a prefix of the input sequence. */
                        return(MatchResult.AutomatonHasPrefix);
                    }

                    // The sequence is a prefix of one of the sequences stored in the automaton.
                    if (seqIndex == end)
                    {
                        return(MatchResult.SequenceIsAPrefix);
                    }

                    // Make a transition along the arc, go the target node's first arc.
                    arc   = fsa.GetFirstArc(fsa.GetEndNode(arc));
                    label = sequence[++seqIndex];
                    continue;
                }
                else
                {
                    if (fsa.IsArcFinal(arc))
                    {
                        hash++;
                    }
                    if (!fsa.IsArcTerminal(arc))
                    {
                        hash += fsa.GetRightLanguageCount(fsa.GetEndNode(arc));
                    }
                }

                arc = fsa.GetNextArc(arc);
            }

            if (seqIndex > start)
            {
                return(MatchResult.AutomatonHasPrefix);
            }
            else
            {
                // Labels of this node ended without a match on the sequence.
                // Perfect hash does not exist.
                return(MatchResult.NoMatch);
            }
        }