Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members  

elementmodel.cpp File Reference

Definitions of ElementModeler class methods. More...

#include "elementmodel.h"

Go to the source code of this file.

Defines

#define INC_TRANSITION_FREQUENCY(_node_, _tr_)
 Increases the frequency count for given transition. More...

#define CREATE_GRAPH_TRANSITION(_from_, _to_)
 Creates a transition bewteen two nodes. More...

#define CREATE_GRAPH_NODE(_pred_, _node_, _type_, _modeler_)
 Creates an element graph node. More...

#define GET_MOST_PROBABLE_TRANSITION(_node_, _mpt_, _definite_)
 Returns the most probable transition leading from the node. More...

#define FIND_TRANSITION(_tr_, _node_, _type_, _modeler_)
 Finds a transition leading to the desired node. More...


Detailed Description

Definitions of ElementModeler class methods.

This file contains definitions of ElementModeler class methods.

Definition in file elementmodel.cpp.


Define Documentation

#define CREATE_GRAPH_NODE _pred_,
_node_,
_type_,
_modeler_   
 

Creates an element graph node.

Parameters:
_pred_  Pointer to the predecessor.
_node_  The created node (output variable).
_type_  The type of the node.
_modeler_  The modeler of the element (used only for element nodes).

Definition at line 98 of file elementmodel.cpp.

Referenced by ElementModeler::ElementModeler, and ElementModeler::moveToDesiredNode.

#define CREATE_GRAPH_TRANSITION _from_,
_to_   
 

Value:

{                                                                       \
  ElementModel::Transition *_tr_;                                       \
                                                                        \
  NEW(_tr_, ElementModel::Transition);                                  \
  _tr_->frequency = 0;                                                  \
  _tr_->id = ((ElementModel::Node *)_from_)->successors.count() + 1;    \
  INC_TRANSITION_FREQUENCY(_from_, _tr_);                               \
  _tr_->node = _to_;                                                    \
                                                                        \
  ((ElementModel::Node *)_from_)->successors.append(_tr_);              \
}
Creates a transition bewteen two nodes.

Parameters:
_from_  The start node.
_to_  The end node.

Definition at line 75 of file elementmodel.cpp.

Referenced by ElementModeler::moveToDesiredNode.

#define FIND_TRANSITION _tr_,
_node_,
_type_,
_modeler_   
 

Value:

{                                                                       \
  _tr_ = 0;                                                             \
  for (ElementModel::Transition *_t_ = _node_->successors.first();      \
       _t_; _t_ = _node_->successors.next())                            \
    {                                                                   \
      if (_t_->node->type == _type_)                                    \
        {                                                               \
          if (_t_->node->type != ElementModel::ElementNode)             \
            {                                                           \
              _tr_ = _t_;                                               \
              INC_TRANSITION_FREQUENCY(_node_, _t_);                    \
              break;                                                    \
            }                                                           \
          else                                                          \
            if (_t_->node->modeler == _modeler_)                        \
              {                                                         \
                _tr_ = _t_;                                             \
                INC_TRANSITION_FREQUENCY(_node_, _tr_);                 \
                break;                                                  \
              }                                                         \
        }                                                               \
    }                                                                   \
}
Finds a transition leading to the desired node.

Parameters:
_tr_  The found transition (output variable).
_node_  The pointer to the graph node.
_type_  The type of the desired node.
_modeler_  The modeler of the desired element (used only for nodes of type ElementNode).

Definition at line 182 of file elementmodel.cpp.

Referenced by ElementModeler::moveToDesiredNode.

#define GET_MOST_PROBABLE_TRANSITION _node_,
_mpt_,
_definite_   
 

Value:

{                                                                               \
  if (_node_->successors.isEmpty())                                             \
    {                                                                           \
      _mpt_ = 0;                                                                \
      _definite_ = true;                                                        \
    }                                                                           \
  else                                                                          \
    {                                                                           \
      _mpt_ = _node_->successors.first();                                       \
      _node_->successors.next();                                                \
      _definite_ = true;                                                        \
                                                                                \
      for (ElementModel::Transition *_tr_ = _node_->successors.current();       \
           _tr_; _tr_ = _node_->successors.next())                              \
        {                                                                       \
          if (_tr_->frequency == _mpt_->frequency)                              \
            {                                                                   \
              _mpt_ = 0;                                                        \
              _definite_ = false;                                               \
            }                                                                   \
          else                                                                  \
            if (_tr_->frequency > _mpt_->frequency)                             \
              {                                                                 \
                _mpt_ = _tr_;                                                   \
                _definite_ = true;                                              \
              }                                                                 \
        }                                                                       \
    }                                                                           \
}
Returns the most probable transition leading from the node.

Parameters:
_node_  Pointer to the graph node.
_mpt_  Pointer to the most probable transition (output variable).
_definite_  Indication whether the most probable transition is definie (output variable).

Definition at line 140 of file elementmodel.cpp.

#define INC_TRANSITION_FREQUENCY _node_,
_tr_   
 

Value:

{                                                       \
  _tr_->frequency++;                                    \
  ElementModel::Node *_tmpnode_ = _node_;               \
                                                        \
  if (_tmpnode_->mpt == _tr_)                           \
    {                                                   \
    }                                                   \
  else                                                  \
    if (!_tmpnode_->mpt)                                \
      {                                                 \
        _tmpnode_->mpt = _tr_;                          \
      }                                                 \
    else                                                \
      if (_tr_->frequency == _tmpnode_->mpt->frequency) \
        {                                               \
          _tmpnode_->mpt = _tr_;                        \
        }                                               \
      else                                              \
        if (_tr_->frequency > _tmpnode_->mpt->frequency)\
          {                                             \
            _tmpnode_->mpt = _tr_;                      \
          }                                             \
}
Increases the frequency count for given transition.

Parameters:
_node_  The pointer to the graph node.
_tr_  The pointer to the transition.

Definition at line 42 of file elementmodel.cpp.

Referenced by ElementModeler::followEdge, and ElementModeler::moveForward.


Generated on Wed Feb 5 10:43:03 2003 for Exalt by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002