DeSR Dependency Parser

src/Sentence.h

/*
**  DeSR
**  src/Sentence.h
** ----------------------------------------------------------------------
**  Copyright (c) 2006  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  DeSR is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef DeSR_Sentence_H
#define DeSR_Sentence_H

#include "Token.h"

namespace Tanl {

class Corpus;

class Sentence : public std::vector<TreeToken*>
{
 public:
  Language const*       language;
  
  Sentence(Language const* language = 0) :
    language(language)
  { }

  Sentence(Sentence const& other) :
    language(other.language) {
    FOR_EACH (Sentence, other, tit)
      push_back(new TreeToken(**tit));
  }

  virtual ~Sentence() {
    FOR_EACH (std::vector<TreeToken*>, *this, it)
      delete *it;
  }

  void                  reverse() {
    int half = size() / 2;
    int j = size() - 1;
    for (int i = 0; i < half; i++, j--) {
      TreeToken* tmpi = operator[](i);
      tmpi->linkHead(size() - tmpi->linkHead() + 1);
      TreeToken* tmpj = operator[](j);
      tmpj->linkHead(size() - tmpj->linkHead() + 1);
      operator[](i) = tmpj;
      operator[](j) = tmpi;
    }
    if (size() % 2) {
      TreeToken* tmp = operator[](half+1);
      tmp->linkHead(size() - tmp->linkHead() + 1);
    }
  }

  void          print(std::ostream& os, Corpus const& corpus);

  TreeToken*    parent(TreeToken* tok) {
    return (tok && tok->linkHead() > 0) ? operator[](tok->linkHead() - 1) : 0;
  }

  TreeToken*    root(TreeToken* tok) {
    while (tok->linkHead() > 0)
      tok = operator[](tok->linkHead() - 1);
    return tok;
  }

  TreeToken*    child(TreeToken* tok, char dir, char POS) {
    if (!tok)
      return 0;
    if (dir == '-') {
      // find closest left child with given POS
      FOR_EACH (std::vector<TreeToken*>, tok->left, it) {
        std::string const* attr = (*it)->get("POS");
        if (attr && (*attr)[0] == POS)
          return *it;
      }
      return 0;
    } else {
      // find closest right child with given POS
      FOR_EACH (std::vector<TreeToken*>, tok->right, it) {
        std::string const* attr = (*it)->get("POS");
        if (attr && (*attr)[0] == POS)
          return *it;
      }
      return 0;
    }
  }

  TreeToken*    child(TreeToken* tok, int nth) {
    if (!tok)
      return 0;
    if (nth < 0) {
      if (nth == INT_MIN)
        return tok->left.size() ? tok->left[tok->left.size() - 1] : 0;
      nth = -nth;
      return (0 < nth && nth <= (int)tok->left.size()) ? tok->left[nth - 1] : 0;
    } else {
      if (nth == INT_MAX)
        return tok->right.size() ? tok->right[tok->right.size() - 1] : 0;
      else
        return  (0 < nth && nth <= (int)tok->right.size()) ? tok->right[nth - 1] : 0;
    }
  }
  
  TreeToken*    leftChild(TreeToken* tok) {
    return (tok && tok->left.size()) ? tok->left[0] : 0;
  }

  TreeToken*    rightChild(TreeToken* tok) {
    return (tok && tok->right.size()) ? tok->left[tok->left.size()-1] : 0;
  }
};

std::ostream& operator <<(std::ostream& os, Sentence const&);

} // namespace Tanl

#endif // DeSR_Sentence_H

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.