---

elementmodel.h

Go to the documentation of this file.

/***************************************************************************
    elementmodel.h  -  Definition of ElementModeler class
                             -------------------
    begin                : November 19 2002
    copyright            : (C) 2003 by Vojtìch Toman
    email                : vtoman@lit.cz
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifdef __GNUG__
# pragma interface
#endif


#ifndef ELEMENTMODEL_H
#define ELEMENTMODEL_H

#include <cmath>

#include "defs.h"
#include "list.h"
#include "stack.h"
#include "xmlchar.h"
#include "saxemitter.h"


#define STR_NODE_TYPE_START_NODE        "S"

#define STR_NODE_TYPE_END_NODE          "/"

#define STR_NODE_TYPE_ELEMENT_NODE      "E"

#define STR_NODE_TYPE_CHARACTERS_NODE   "C"


class ElementModeler;   //forward declaration


namespace ElementModel
{
  struct Node;          //forward declaration, see below


  struct Transition
  {
    size_t frequency;

    size_t id;

    Node *node;
  };


  typedef List<Transition> Transitions;


  enum NodeType
  {
    NoNode,

    StartNode,

    EndNode,

    CharactersNode,

    ElementNode,
  };


  enum TransitionState
  {
    Definite,

    Indefinite,

    NewNodeCreated,

    Impossible
  };


  struct Node
  {
    unsigned long id;

    NodeType type;

    Transitions successors;

    Transition *mpt;

    ElementModeler *modeler;
  };

  struct AttributeNode : public Node
  {
    size_t noAttrCnt;

    size_t yesAttrCnt;

    bool hasAttr;
  };


  typedef Stack<Node> NodeStack;
};



class ElementModeler
{
public:
  ElementModeler(XmlChar *name);

  virtual ~ElementModeler(void);

  virtual void resetCurrentNode(void);

  virtual void popCurrentNode(void);

  virtual ElementModel::Node *getCurrentNode(void);

  virtual ElementModel::TransitionState moveToDesiredNode(ElementModel::NodeType desiredNodeType, size_t *edgeId, size_t *elementPushes, ElementModeler *elementModeler = 0);

  virtual ElementModel::NodeType moveForward(ElementModel::Node **node, SAXEmitter *saxEmitter, void *userData);

  virtual ElementModel::NodeType followEdge(size_t edgeId, ElementModel::Node **node, SAXEmitter *saxEmitter, void *userData);

  virtual ElementModel::NodeType currentNodeType(void);

  virtual bool setAttributes(bool attributes);

  virtual bool hasAttributes(void);

  virtual ElementModel::Node *getStartNode(void);

  virtual ElementModel::Node *getEndNode(void);

  virtual XmlChar *getElementName(void);

  virtual void increaseRefCount(void);

  virtual size_t getRefCount(void);

  virtual void computeAverageEntropy(void);

  virtual double getAverageEntropy(void);

  virtual void print(void);

  virtual void printNode(ElementModel::Node *node);


protected:
  XmlChar *elementName;

  ElementModel::AttributeNode *startNode;

  ElementModel::Node *endNode;

  ElementModel::Node *currentNode;

  ElementModel::NodeStack nodeStack;

  size_t nodeCounter;

  size_t refCount;

  double averageEntropy;

  List<ElementModel::Node> nodeList;
};



struct ElementModelerInfo
{
  ElementModeler *modeler;

  bool building;
};


struct ElementModelTransitionInfo
{
  double probability;

  ElementModel::Transition *transition;
};


class ElementModelEntropyCalculator
{
 public:
  static double calculate(ElementModeler *modeler);
};



#endif //ELEMENTMODEL_H

---