QPatternist::XsdStateMachine< TransitionType > Class Template Reference

A state machine used for evaluation. More...

#include <qxsdstatemachine_p.h>

Public Types
typedef qint32	StateId
enum	StateType { StartState, StartEndState, InternalState, EndState }

Public Functions
void	addEpsilonTransition (StateId start, StateId end)
StateId	addState (StateType type)
void	addTransition (StateId start, TransitionType transition, StateId end)
void	clear ()
bool	inEndState () const
template<>
bool	inputEqualsTransition (QXmlName name, XsdTerm::Ptr term) const
template<typename InputType >
bool	inputEqualsTransition (InputType input, TransitionType transition) const
template<typename InputType >
bool	inputEqualsTransition (InputType input, TransitionType transition) const
TransitionType	lastTransition () const
bool	outputGraph (QIODevice *device, const QString &graphName) const
QList< TransitionType >	possibleTransitions () const
template<typename TransitionType >
bool	proceed (TransitionType transition)
bool	proceed (TransitionType transition)
template<typename InputType >
bool	proceed (InputType input)
template<typename InputType >
bool	proceed (InputType input)
void	reset ()
StateId	startState () const
QHash< StateId, StateType >	states () const
XsdStateMachine< TransitionType >	toDFA () const
QHash< StateId, QHash< TransitionType, QVector< StateId > > >	transitions () const
template<>
QString	transitionTypeToString (XsdTerm::Ptr term) const
QString	transitionTypeToString (TransitionType type) const
	XsdStateMachine ()
	XsdStateMachine (const NamePool::Ptr &namePool)

Private Functions
StateId	dfaStateForNfaState (QSet< StateId > nfaState, QList< QPair< QSet< StateId >, StateId > > &stateTable, XsdStateMachine< TransitionType > &dfa) const
QSet< StateId >	epsilonClosure (const QSet< StateId > &input) const
QSet< StateId >	move (const QSet< StateId > &states, TransitionType input) const

Properties
qint32	m_counter
StateId	m_currentState
QHash< StateId, QVector< StateId > >	m_epsilonTransitions
TransitionType	m_lastTransition
NamePool::Ptr	m_namePool
QHash< StateId, StateType >	m_states
QHash< StateId, QHash< TransitionType, QVector< StateId > > >	m_transitions

Detailed Description

template<typename TransitionType>
class QPatternist::XsdStateMachine< TransitionType >

A state machine used for evaluation.

Author

Tobias Koenig tobia.nosp@m.s.ko.nosp@m.enig@.nosp@m.noki.nosp@m.a.com

Definition at line 76 of file qxsdstatemachine_p.h.

Typedefs

StateId

template<typename TransitionType>

typedef qint32 QPatternist::XsdStateMachine< TransitionType >::StateId

Definition at line 79 of file qxsdstatemachine_p.h.

Enumerations

StateType

template<typename TransitionType>

enum QPatternist::XsdStateMachine::StateType

Describes the type of state.

Enumerator
StartState	The state the machine will start with.
StartEndState	The state the machine will start with, can be end state as well.
InternalState	Any state that is not start or end state.
EndState	Any state where the machine is allowed to stop.

Definition at line 84 of file qxsdstatemachine_p.h.

            {
                StartState,     
                StartEndState,  
                InternalState,  
                EndState        
            };

Constructors and Destructors

XsdStateMachine() [1/2]

template<typename TransitionType >

QPatternist::XsdStateMachine< TransitionType >::XsdStateMachine

(

)

Creates a new state machine object.

Definition at line 48 of file qxsdstatemachine.cpp.

    : m_counter(50)
{
}

XsdStateMachine() [2/2]

template<typename TransitionType >

QPatternist::XsdStateMachine< TransitionType >::XsdStateMachine

(

const NamePool::Ptr &

namePool

)

Creates a new state machine object.

The name pool to use for accessing object names.

Definition at line 54 of file qxsdstatemachine.cpp.

    : m_namePool(namePool)
    , m_counter(50)
{
}

Functions

addEpsilonTransition()

template<typename TransitionType >

void QPatternist::XsdStateMachine< TransitionType >::addEpsilonTransition	(	StateId	start,
		StateId	end
	)

Adds a new epsilon transition to the state machine.

Parameters

start	The start state.
end	The end state.

Definition at line 95 of file qxsdstatemachine.cpp.

{
    QVector<StateId> &states = m_epsilonTransitions[start];
    states.append(end);
}

addState()

template<typename TransitionType >

XsdStateMachine< TransitionType >::StateId QPatternist::XsdStateMachine< TransitionType >::addState

(

StateType

type

)

Adds a new state of the given type to the state machine.

Returns

The id of the new state.

Definition at line 61 of file qxsdstatemachine.cpp.

Referenced by QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::dfaStateForNfaState(), and QPatternist::XsdSchemaParser::setupStateMachines().

{
#ifndef QT_NO_DEBUG
    // make sure we don't have two start states
    if (type == StartState) {
        QHashIterator<StateId, StateType> it(m_states);
        while (it.hasNext()) {
            it.next();
            Q_ASSERT(it.value() != StartState && it.value() != StartEndState);
        }
    }
#endif // QT_NO_DEBUG

    // reserve new state id
    const StateId id = ++m_counter;
    m_states.insert(id, type);

    // if it is a start state, we make it to our current state
    if (type == StartState || type == StartEndState)
        m_currentState = id;

    return id;
}

addTransition()

template<typename TransitionType>

void QPatternist::XsdStateMachine< TransitionType >::addTransition	(	StateId	start,
		TransitionType	transition,
		StateId	end
	)

Adds a new transition to the state machine.

Parameters

start	The start state.
transition	The transition to come from the start to the end state.
end	The end state.

Definition at line 86 of file qxsdstatemachine.cpp.

Referenced by QPatternist::XsdSchemaParser::setupStateMachines(), and QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::toDFA().

{
    QHash<TransitionType, QVector<StateId> > &hash = m_transitions[start];
    QVector<StateId> &states = hash[transition];
    if (!states.contains(end))
        states.append(end);
}

clear()

template<typename TransitionType >

void QPatternist::XsdStateMachine< TransitionType >::clear

(

void

)

Removes all states and transitions from the state machine.

Definition at line 118 of file qxsdstatemachine.cpp.

{
    m_states.clear();
    m_transitions.clear();
    m_epsilonTransitions.clear();
    m_currentState = -1;
    m_counter = 50;
}

dfaStateForNfaState()

template<typename TransitionType>

XsdStateMachine< TransitionType >::StateId QPatternist::XsdStateMachine< TransitionType >::dfaStateForNfaState ( QSet< StateId >  nfaState, QList< QPair< QSet< StateId >, StateId > > &  stateTable, XsdStateMachine< TransitionType > &  dfa  ) const

private

Returns the DFA state for the given nfaStat from the given stateTable. If there is no corresponding DFA state yet, a new one is created.

Definition at line 294 of file qxsdstatemachine.cpp.

Referenced by QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::transitions().

{
    // check whether we have the given state in our lookup table
    // already, in that case simply return it
    for (int i = 0; i < stateTable.count(); ++i) {
        if (stateTable.at(i).first == nfaState)
            return stateTable.at(i).second;
    }

    // check if the NFA state set contains a Start or End
    // state, in that case our new DFA state will be a
    // Start or End state as well
    StateType type = InternalState;
    QSetIterator<StateId> it(nfaState);
    bool hasStartState = false;
    bool hasEndState = false;
    while (it.hasNext()) {
        const StateId state = it.next();
        if (m_states.value(state) == EndState) {
            hasEndState = true;
        } else if (m_states.value(state) == StartState) {
            hasStartState = true;
        }
    }
    if (hasStartState) {
        if (hasEndState)
            type = StartEndState;
        else
            type = StartState;
    } else if (hasEndState) {
        type = EndState;
    }

    // create the new DFA state
    const StateId dfaState = dfa.addState(type);

    // add the new DFA state to the lookup table
    stateTable.append(qMakePair<QSet<StateId>, StateId>(nfaState, dfaState));

    return dfaState;
}

epsilonClosure()

template<typename TransitionType>

QSet<StateId> QPatternist::XsdStateMachine< TransitionType >::epsilonClosure ( const QSet< StateId > &  input ) const

inlineprivate

Returns the set of all states that can be reached from the set of input states by the epsilon transition.

The implementation is inlined in order to workaround a compiler bug on Symbian/winscw.

Definition at line 230 of file qxsdstatemachine_p.h.

            {
                // every state can reach itself by epsilon transition, so include the input states
                // in the result as well
                QSet<StateId> result = input;

                // add the input states to the list of to be processed states
                QList<StateId> workStates = input.toList();
                while (!workStates.isEmpty()) { // while there are states to be processed left...

                    // dequeue one state from list
                    const StateId state = workStates.takeFirst();

                    // get the list of states that can be reached by the epsilon transition
                    // from the current 'state'
                    const QVector<StateId> targetStates = m_epsilonTransitions.value(state);
                    for (int i = 0; i < targetStates.count(); ++i) {
                        // if we have this target state not in our result set yet...
                        if (!result.contains(targetStates.at(i))) {
                            // ... add it to the result set
                            result.insert(targetStates.at(i));

                            // add the target state to the list of to be processed states as well,
                            // as we want to have the epsilon transitions not only for the first
                            // level of following states
                            workStates.append(targetStates.at(i));
                        }
                    }
                }

                return result;
            }

inEndState()

template<typename TransitionType >

bool QPatternist::XsdStateMachine< TransitionType >::inEndState

(

)

const

Returns whether the machine is in an allowed end state.

Definition at line 192 of file qxsdstatemachine.cpp.

{
    // check if current state is an end state
    return (m_states.value(m_currentState) == StartEndState || m_states.value(m_currentState) == EndState);
}

inputEqualsTransition() [1/3]

template<>

bool QPatternist::XsdStateMachine< XsdTerm::Ptr >::inputEqualsTransition< QXmlName >	(	QXmlName	name,
		XsdTerm::Ptr	term
	)		const

Definition at line 81 of file qxsdvalidatinginstancereader.cpp.

    {
        if (term->isElement()) {
            return (XsdElement::Ptr(term)->name(m_namePool) == name);
        } else if (term->isWildcard()) {
            // wildcards using XsdWildcard::absentNamespace, so we have to fix that here
            if (name.namespaceURI() == StandardNamespaces::empty) {
                name.setNamespaceURI(m_namePool->allocateNamespace(XsdWildcard::absentNamespace()));
            }

            return XsdSchemaHelper::wildcardAllowsExpandedName(name, XsdWildcard::Ptr(term), m_namePool);
        }

        return false;
    }

inputEqualsTransition() [2/3]

template<typename TransitionType>

template<typename InputType >

bool QPatternist::XsdStateMachine< TransitionType >::inputEqualsTransition	(	InputType	input,
		TransitionType	transition
	)		const

Returns whether the given input matches the given transition.

Definition at line 187 of file qxsdstatemachine_p.h.

            {

inputEqualsTransition() [3/3]

template<typename TransitionType>

template<typename InputType >

bool QPatternist::XsdStateMachine< TransitionType >::inputEqualsTransition	(	InputType	input,
		TransitionType	transition
	)		const

Definition at line 186 of file qxsdstatemachine.cpp.

{
    return false;
}

lastTransition()

template<typename TransitionType >

TransitionType QPatternist::XsdStateMachine< TransitionType >::lastTransition

(

)

const

Returns the last transition that was taken.

Definition at line 199 of file qxsdstatemachine.cpp.

{
    return m_lastTransition;
}

move()

template<typename TransitionType>

QSet<StateId> QPatternist::XsdStateMachine< TransitionType >::move ( const QSet< StateId > &  states, TransitionType  input  ) const

inlineprivate

Returns the set of all states that can be reached from the set of given states by the given input.

The implementation is inlined in order to workaround a compiler bug on Symbian/winscw.

Definition at line 270 of file qxsdstatemachine_p.h.

            {
                QSet<StateId> result;

                QSetIterator<StateId> it(states);
                while (it.hasNext()) { // iterate over all given states
                    const StateId state = it.next();

                    // get the transition table for the current state
                    const QHash<TransitionType, QVector<StateId> > transitions = m_transitions.value(state);

                    // get the target states for the given input
                    const QVector<StateId> targetStates = transitions.value(input);

                    // add all target states to the result
                    for (int i = 0; i < targetStates.size(); ++i)
                        result.insert(targetStates.at(i));
                }

                return result;
            }

outputGraph()

template<typename TransitionType >

bool QPatternist::XsdStateMachine< TransitionType >::outputGraph	(	QIODevice *	device,
		const QString &	graphName
	)		const

Outputs the state machine in DOT format to the given output device.

Definition at line 227 of file qxsdstatemachine.cpp.

{
    if (!device->isOpen()) {
        qWarning("device must be open for writing");
        return false;
    }

    QByteArray graph;
    QTextStream s(&graph);

    QHashIterator<StateId, QHash<TransitionType, QVector<StateId> > > it(m_transitions);
    QHashIterator<StateId, StateType> it3(m_states);

    s << "digraph " << graphName << " {\n";
    s << "  mindist = 2.0\n";

    // draw edges
    while (it.hasNext()) {
        it.next();

        QHashIterator<TransitionType, QVector<StateId> > it2(it.value());
        while (it2.hasNext()) {
            it2.next();
            for (int i = 0; i < it2.value().count(); ++i)
                s << "  " << it.key() << " -> " << it2.value().at(i) << " [label=\"" << transitionTypeToString(it2.key()) << "\"]\n";
        }
    }

    QHashIterator<StateId, QVector<StateId> > it4(m_epsilonTransitions);
    while (it4.hasNext()) {
        it4.next();

        const QVector<StateId> states = it4.value();
        for (int i = 0; i < states.count(); ++i)
            s << "  " << it4.key() << " -> " << states.at(i) << " [label=\"&#949;\"]\n";
    }

    // draw node infos
    while (it3.hasNext()) {
        it3.next();

        QString style;
        if (it3.value() == StartState) {
            style = QLatin1String("shape=circle, style=filled, color=blue");
        } else if (it3.value() == StartEndState) {
            style = QLatin1String("shape=doublecircle, style=filled, color=blue");
        } else if (it3.value() == InternalState) {
            style = QLatin1String("shape=circle, style=filled, color=red");
        } else if (it3.value() == EndState) {
            style = QLatin1String("shape=doublecircle, style=filled, color=green");
        }

        s << "  " << it3.key() << " [" << style << "]\n";
    }

    s << "}\n";

    s.flush();

    if (device->write(graph) == -1)
        return false;

    return true;
}

possibleTransitions()

template<typename TransitionType >

QList< TransitionType > QPatternist::XsdStateMachine< TransitionType >::possibleTransitions

(

)

const

Returns the list of transitions that are reachable from the current state.

Definition at line 147 of file qxsdstatemachine.cpp.

{
    // check that we are not in an invalid state
    if (!m_transitions.contains(m_currentState)) {
        return QList<TransitionType>();
    }

    // fetch the transition entry for the current state
    const QHash<TransitionType, QVector<StateId> > &entry = m_transitions[m_currentState];

    return entry.keys();
}

proceed() [1/4]

template<typename TransitionType>

template<typename TransitionType >

bool QPatternist::XsdStateMachine< TransitionType >::proceed

(

TransitionType

transition

)

Definition at line 128 of file qxsdstatemachine.cpp.

{
    // check that we are not in an invalid state
    if (!m_transitions.contains(m_currentState)) {
        return false;
    }

    // fetch the transition entry for the current state
    const QHash<TransitionType, QVector<StateId> > &entry = m_transitions[m_currentState];
    if (entry.contains(transition)) { // is there an transition for the given input?
        m_currentState = entry.value(transition).first();
        m_lastTransition = transition;
        return true;
    } else {
        return false;
    }
}

proceed() [2/4]

template<typename TransitionType>

bool QPatternist::XsdStateMachine< TransitionType >::proceed

(

TransitionType

transition

)

Continues execution of the machine with the given input transition.

Returns

true if the transition was successful, false otherwise.

Definition at line 129 of file qxsdstatemachine_p.h.

            {

proceed() [3/4]

template<typename TransitionType >

template<typename InputType >

bool QPatternist::XsdStateMachine< TransitionType >::proceed

(

InputType

input

)

Continues execution of the machine with the given input.

Note

To use this method, inputEqualsTransition must be implemented to find the right transition to use.

Returns

true if the transition was successful, false otherwise.

Definition at line 163 of file qxsdstatemachine_p.h.

            {

proceed() [4/4]

template<typename TransitionType>

template<typename InputType >

bool QPatternist::XsdStateMachine< TransitionType >::proceed

(

InputType

input

)

Definition at line 162 of file qxsdstatemachine.cpp.

{
    // check that we are not in an invalid state
    if (!m_transitions.contains(m_currentState)) {
        return false;
    }

    // fetch the transition entry for the current state
    const QHash<TransitionType, QVector<StateId> > &entry = m_transitions[m_currentState];
    QHashIterator<TransitionType, QVector<StateId> > it(entry);
    while (it.hasNext()) {
        it.next();
        if (inputEqualsTransition(input, it.key())) {
            m_currentState = it.value().first();
            m_lastTransition = it.key();
            return true;
        }
    }

    return false;
}

reset()

template<typename TransitionType >

void QPatternist::XsdStateMachine< TransitionType >::reset

(

)

Resets the machine to the start state.

Definition at line 102 of file qxsdstatemachine.cpp.

{
    // reset the machine to the start state
    QHashIterator<StateId, StateType> it(m_states);
    while (it.hasNext()) {
        it.next();
        if (it.value() == StartState || it.value() == StartEndState) {
            m_currentState = it.key();
            return;
        }
    }

    Q_ASSERT(false);
}

startState()

template<typename TransitionType >

XsdStateMachine< TransitionType >::StateId QPatternist::XsdStateMachine< TransitionType >::startState

(

)

const

Returns the start state of the machine.

Definition at line 205 of file qxsdstatemachine.cpp.

Referenced by QPatternist::XsdParticleChecker::subsumes().

{
    QHashIterator<StateId, StateType> it(m_states);
    while (it.hasNext()) {
        it.next();
        if (it.value() == StartState || it.value() == StartEndState)
            return it.key();
    }

    Q_ASSERT(false); // should never be reached
    return -1;
}

states()

template<typename TransitionType >

QHash< typename XsdStateMachine< TransitionType >::StateId, typename XsdStateMachine< TransitionType >::StateType > QPatternist::XsdStateMachine< TransitionType >::states

(

)

const

Returns the information of all states of the state machine.

Definition at line 410 of file qxsdstatemachine.cpp.

Referenced by QPatternist::XsdParticleChecker::isUPAConform(), and QPatternist::XsdParticleChecker::subsumes().

{
    return m_states;
}

toDFA()

template<typename TransitionType >

XsdStateMachine< TransitionType > QPatternist::XsdStateMachine< TransitionType >::toDFA

(

)

const

Returns a DFA that is equal to the NFA of the state machine.

Definition at line 339 of file qxsdstatemachine.cpp.

Referenced by QPatternist::XsdValidatingInstanceReader::createAndPushStateMachine(), QPatternist::XsdParticleChecker::isUPAConform(), and QPatternist::XsdParticleChecker::subsumes().

{
    XsdStateMachine<TransitionType> dfa(m_namePool);
    dfa.m_counter = 100;
    QList< QPair< QSet<StateId>, StateId> > table;
    QList< QSet<StateId> > isMarked;

    // search the start state as the algorithm starts with it...
    StateId startState = -1;
    QHashIterator<StateId, StateType> stateTypeIt(m_states);
    while (stateTypeIt.hasNext()) {
        stateTypeIt.next();
        if (stateTypeIt.value() == StartState) {
            startState = stateTypeIt.key();
            break;
        }
    }
    Q_ASSERT(startState != -1);

    // our list of state set that still have to be processed
    QList< QSet<StateId> > workStates;

    // add the start state to the list of to processed state sets
    workStates.append(epsilonClosure(QSet<StateId>() << startState));

    while (!workStates.isEmpty()) { // as long as there are state sets to process left

        // enqueue set of states
        const QSet<StateId> states = workStates.takeFirst();

        if (isMarked.contains(states)) // we processed this state set already
            continue;

        // mark as processed
        isMarked.append(states);

        // select a list of all inputs that are possible for
        // the 'states' set
        QList<TransitionType> input;

        {
            QSetIterator<StateId> it(states);
            while (it.hasNext()) {
                input << m_transitions.value(it.next()).keys();
            }
        }

        // get the state in DFA that corresponds to the 'states' set in the NFA
        const StateId dfaBegin = dfaStateForNfaState(states, table, dfa);

        for (int i = 0; i < input.count(); ++i) { // for each possible input
            // retrieve the states that can  be reached from the 'states' set by the
            // given input or by epsilon transition
            const QSet<StateId> followStates = epsilonClosure(move(states, input.at(i)));

            // get the state in DFA that corresponds to the 'followStates' set in the NFA
            const StateId dfaEnd = dfaStateForNfaState(followStates, table, dfa);

            // adds a new transition to the DFA that corresponds to the transitions between
            // 'states' and 'followStates' in the NFA
            dfa.addTransition(dfaBegin, input.at(i), dfaEnd);

            // add the 'followStates' to the list of to be processed state sets
            workStates.append(followStates);
        }
    }

    return dfa;
}

transitions()

template<typename TransitionType>

QHash<StateId, QHash<TransitionType, QVector<StateId> > > QPatternist::XsdStateMachine< TransitionType >::transitions ( ) const

inline

Returns the information of all transitions of the state machine.

The implementation is inlined in order to workaround a compiler bug on Symbian/winscw.

Definition at line 211 of file qxsdstatemachine_p.h.

Referenced by QPatternist::XsdParticleChecker::isUPAConform(), QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::move(), and QPatternist::XsdParticleChecker::subsumes().

            {
                return m_transitions;
            }

transitionTypeToString() [1/2]

template<>

QString QPatternist::XsdStateMachine< XsdTerm::Ptr >::transitionTypeToString

(

XsdTerm::Ptr

term

)

const

This template specialization is picked up by XsdStateMachine and allows us to print nice edge labels.

Definition at line 64 of file qxsdparticlechecker.cpp.

    {
        if (!term)
            return QLatin1String("(empty)");

        if (term->isElement()) {
            return XsdElement::Ptr(term)->displayName(m_namePool);
        } else if (term->isWildcard()) {
            const XsdWildcard::Ptr wildcard(term);
            return QLatin1String("(wildcard)");
        } else {
            return QString();
        }
    }

transitionTypeToString() [2/2]

template<typename TransitionType>

QString QPatternist::XsdStateMachine< TransitionType >::transitionTypeToString

(

TransitionType

type

)

const

This method should be redefined by template specialization for every concret TransitionType.

Definition at line 219 of file qxsdstatemachine.cpp.

{
    Q_UNUSED(type)

    return QString();
}

Properties

m_counter

template<typename TransitionType>

qint32 QPatternist::XsdStateMachine< TransitionType >::m_counter

private

Definition at line 297 of file qxsdstatemachine_p.h.

Referenced by QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::toDFA().

m_currentState

template<typename TransitionType>

StateId QPatternist::XsdStateMachine< TransitionType >::m_currentState

private

Definition at line 296 of file qxsdstatemachine_p.h.

m_epsilonTransitions

template<typename TransitionType>

QHash<StateId, QVector<StateId> > QPatternist::XsdStateMachine< TransitionType >::m_epsilonTransitions

private

Definition at line 295 of file qxsdstatemachine_p.h.

Referenced by QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::epsilonClosure().

m_lastTransition

template<typename TransitionType>

TransitionType QPatternist::XsdStateMachine< TransitionType >::m_lastTransition

private

Definition at line 298 of file qxsdstatemachine_p.h.

m_namePool

template<typename TransitionType>

NamePool::Ptr QPatternist::XsdStateMachine< TransitionType >::m_namePool

private

Definition at line 292 of file qxsdstatemachine_p.h.

m_states

template<typename TransitionType>

QHash<StateId, StateType> QPatternist::XsdStateMachine< TransitionType >::m_states

private

Definition at line 293 of file qxsdstatemachine_p.h.

m_transitions

template<typename TransitionType>

QHash<StateId, QHash<TransitionType, QVector<StateId> > > QPatternist::XsdStateMachine< TransitionType >::m_transitions

private

Definition at line 294 of file qxsdstatemachine_p.h.

Referenced by QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::move(), and QPatternist::XsdStateMachine< XsdSchemaToken::NodeName >::transitions().

---

The documentation for this class was generated from the following files:

• /src/xmlpatterns/schema/qxsdstatemachine_p.h
• /src/xmlpatterns/schema/qxsdstatemachine.cpp